1 #!/bin/bash
   2 #
   3 # ##########################################################
   4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
   5 # ##########################################################
   6 #
   7 #! /bin/sh
   8 # Guess values for system-dependent variables and create Makefiles.
   9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
  10 #
  11 # Report bugs to <build-dev@openjdk.java.net>.
  12 #
  13 #
  14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
  15 #
  16 #
  17 # This configure script is free software; the Free Software Foundation
  18 # gives unlimited permission to copy, distribute and modify it.
  19 ## -------------------- ##
  20 ## M4sh Initialization. ##
  21 ## -------------------- ##
  22 
  23 # Be more Bourne compatible
  24 DUALCASE=1; export DUALCASE # for MKS sh
  25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  26   emulate sh
  27   NULLCMD=:
  28   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  29   # is contrary to our usage.  Disable this feature.
  30   alias -g '${1+"$@"}'='"$@"'
  31   setopt NO_GLOB_SUBST
  32 else
  33   case `(set -o) 2>/dev/null` in #(
  34   *posix*) :
  35     set -o posix ;; #(
  36   *) :
  37      ;;
  38 esac
  39 fi
  40 
  41 
  42 as_nl='
  43 '
  44 export as_nl
  45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
  46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
  47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
  48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
  49 # Prefer a ksh shell builtin over an external printf program on Solaris,
  50 # but without wasting forks for bash or zsh.
  51 if test -z "$BASH_VERSION$ZSH_VERSION" \
  52     && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  53   as_echo='print -r --'
  54   as_echo_n='print -rn --'
  55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  56   as_echo='printf %s\n'
  57   as_echo_n='printf %s'
  58 else
  59   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
  60     as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
  61     as_echo_n='/usr/ucb/echo -n'
  62   else
  63     as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
  64     as_echo_n_body='eval
  65       arg=$1;
  66       case $arg in #(
  67       *"$as_nl"*)
  68         expr "X$arg" : "X\\(.*\\)$as_nl";
  69         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
  70       esac;
  71       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
  72     '
  73     export as_echo_n_body
  74     as_echo_n='sh -c $as_echo_n_body as_echo'
  75   fi
  76   export as_echo_body
  77   as_echo='sh -c $as_echo_body as_echo'
  78 fi
  79 
  80 # The user is always right.
  81 if test "${PATH_SEPARATOR+set}" != set; then
  82   PATH_SEPARATOR=:
  83   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
  84     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
  85       PATH_SEPARATOR=';'
  86   }
  87 fi
  88 
  89 
  90 # IFS
  91 # We need space, tab and new line, in precisely that order.  Quoting is
  92 # there to prevent editors from complaining about space-tab.
  93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
  94 # splitting by setting IFS to empty value.)
  95 IFS=" ""        $as_nl"
  96 
  97 # Find who we are.  Look in the path if we contain no directory separator.
  98 as_myself=
  99 case $0 in #((
 100   *[\\/]* ) as_myself=$0 ;;
 101   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 102 for as_dir in $PATH
 103 do
 104   IFS=$as_save_IFS
 105   test -z "$as_dir" && as_dir=.
 106     test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 107   done
 108 IFS=$as_save_IFS
 109 
 110      ;;
 111 esac
 112 # We did not find ourselves, most probably we were run as `sh COMMAND'
 113 # in which case we are not to be found in the path.
 114 if test "x$as_myself" = x; then
 115   as_myself=$0
 116 fi
 117 if test ! -f "$as_myself"; then
 118   $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
 119   exit 1
 120 fi
 121 
 122 # Unset variables that we do not need and which cause bugs (e.g. in
 123 # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
 124 # suppresses any "Segmentation fault" message there.  '((' could
 125 # trigger a bug in pdksh 5.2.14.
 126 for as_var in BASH_ENV ENV MAIL MAILPATH
 127 do eval test x\${$as_var+set} = xset \
 128   && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
 129 done
 130 PS1='$ '
 131 PS2='> '
 132 PS4='+ '
 133 
 134 # NLS nuisances.
 135 LC_ALL=C
 136 export LC_ALL
 137 LANGUAGE=C
 138 export LANGUAGE
 139 
 140 # CDPATH.
 141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 142 
 143 # Use a proper internal environment variable to ensure we don't fall
 144   # into an infinite loop, continuously re-executing ourselves.
 145   if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
 146     _as_can_reexec=no; export _as_can_reexec;
 147     # We cannot yet assume a decent shell, so we have to provide a
 148 # neutralization value for shells without unset; and this also
 149 # works around shells that cannot unset nonexistent variables.
 150 # Preserve -v and -x to the replacement shell.
 151 BASH_ENV=/dev/null
 152 ENV=/dev/null
 153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 154 case $- in # ((((
 155   *v*x* | *x*v* ) as_opts=-vx ;;
 156   *v* ) as_opts=-v ;;
 157   *x* ) as_opts=-x ;;
 158   * ) as_opts= ;;
 159 esac
 160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 161 # Admittedly, this is quite paranoid, since all the known shells bail
 162 # out after a failed `exec'.
 163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 164 as_fn_exit 255
 165   fi
 166   # We don't want this to propagate to other subprocesses.
 167           { _as_can_reexec=; unset _as_can_reexec;}
 168 if test "x$CONFIG_SHELL" = x; then
 169   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
 170   emulate sh
 171   NULLCMD=:
 172   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
 173   # is contrary to our usage.  Disable this feature.
 174   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 175   setopt NO_GLOB_SUBST
 176 else
 177   case \`(set -o) 2>/dev/null\` in #(
 178   *posix*) :
 179     set -o posix ;; #(
 180   *) :
 181      ;;
 182 esac
 183 fi
 184 "
 185   as_required="as_fn_return () { (exit \$1); }
 186 as_fn_success () { as_fn_return 0; }
 187 as_fn_failure () { as_fn_return 1; }
 188 as_fn_ret_success () { return 0; }
 189 as_fn_ret_failure () { return 1; }
 190 
 191 exitcode=0
 192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
 193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
 194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
 195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 197 
 198 else
 199   exitcode=1; echo positional parameters were not saved.
 200 fi
 201 test x\$exitcode = x0 || exit 1
 202 test -x / || exit 1"
 203   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
 204   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
 205   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
 206   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
 207 test \$(( 1 + 1 )) = 2 || exit 1"
 208   if (eval "$as_required") 2>/dev/null; then :
 209   as_have_required=yes
 210 else
 211   as_have_required=no
 212 fi
 213   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 214 
 215 else
 216   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 217 as_found=false
 218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 219 do
 220   IFS=$as_save_IFS
 221   test -z "$as_dir" && as_dir=.
 222   as_found=:
 223   case $as_dir in #(
 224          /*)
 225            for as_base in sh bash ksh sh5; do
 226              # Try only shells that exist, to save several forks.
 227              as_shell=$as_dir/$as_base
 228              if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 229                     { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
 230   CONFIG_SHELL=$as_shell as_have_required=yes
 231                    if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
 232   break 2
 233 fi
 234 fi
 235            done;;
 236        esac
 237   as_found=false
 238 done
 239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 240               { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
 241   CONFIG_SHELL=$SHELL as_have_required=yes
 242 fi; }
 243 IFS=$as_save_IFS
 244 
 245 
 246       if test "x$CONFIG_SHELL" != x; then :
 247   export CONFIG_SHELL
 248              # We cannot yet assume a decent shell, so we have to provide a
 249 # neutralization value for shells without unset; and this also
 250 # works around shells that cannot unset nonexistent variables.
 251 # Preserve -v and -x to the replacement shell.
 252 BASH_ENV=/dev/null
 253 ENV=/dev/null
 254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 255 case $- in # ((((
 256   *v*x* | *x*v* ) as_opts=-vx ;;
 257   *v* ) as_opts=-v ;;
 258   *x* ) as_opts=-x ;;
 259   * ) as_opts= ;;
 260 esac
 261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 262 # Admittedly, this is quite paranoid, since all the known shells bail
 263 # out after a failed `exec'.
 264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 265 exit 255
 266 fi
 267 
 268     if test x$as_have_required = xno; then :
 269   $as_echo "$0: This script requires a shell more modern than all"
 270   $as_echo "$0: the shells that I found on your system."
 271   if test x${ZSH_VERSION+set} = xset ; then
 272     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
 273     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
 274   else
 275     $as_echo "$0: Please tell bug-autoconf@gnu.org and
 276 $0: build-dev@openjdk.java.net about your system, including
 277 $0: any error possibly output before this message. Then
 278 $0: install a modern shell, or manually run the script
 279 $0: under such a shell if you do have one."
 280   fi
 281   exit 1
 282 fi
 283 fi
 284 fi
 285 SHELL=${CONFIG_SHELL-/bin/sh}
 286 export SHELL
 287 # Unset more variables known to interfere with behavior of common tools.
 288 CLICOLOR_FORCE= GREP_OPTIONS=
 289 unset CLICOLOR_FORCE GREP_OPTIONS
 290 
 291 ## --------------------- ##
 292 ## M4sh Shell Functions. ##
 293 ## --------------------- ##
 294 # as_fn_unset VAR
 295 # ---------------
 296 # Portably unset VAR.
 297 as_fn_unset ()
 298 {
 299   { eval $1=; unset $1;}
 300 }
 301 as_unset=as_fn_unset
 302 
 303 # as_fn_set_status STATUS
 304 # -----------------------
 305 # Set $? to STATUS, without forking.
 306 as_fn_set_status ()
 307 {
 308   return $1
 309 } # as_fn_set_status
 310 
 311 # as_fn_exit STATUS
 312 # -----------------
 313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
 314 as_fn_exit ()
 315 {
 316   set +e
 317   as_fn_set_status $1
 318   exit $1
 319 } # as_fn_exit
 320 
 321 # as_fn_mkdir_p
 322 # -------------
 323 # Create "$as_dir" as a directory, including parents if necessary.
 324 as_fn_mkdir_p ()
 325 {
 326 
 327   case $as_dir in #(
 328   -*) as_dir=./$as_dir;;
 329   esac
 330   test -d "$as_dir" || eval $as_mkdir_p || {
 331     as_dirs=
 332     while :; do
 333       case $as_dir in #(
 334       *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
 335       *) as_qdir=$as_dir;;
 336       esac
 337       as_dirs="'$as_qdir' $as_dirs"
 338       as_dir=`$as_dirname -- "$as_dir" ||
 339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 340          X"$as_dir" : 'X\(//\)[^/]' \| \
 341          X"$as_dir" : 'X\(//\)$' \| \
 342          X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 343 $as_echo X"$as_dir" |
 344     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 345             s//\1/
 346             q
 347           }
 348           /^X\(\/\/\)[^/].*/{
 349             s//\1/
 350             q
 351           }
 352           /^X\(\/\/\)$/{
 353             s//\1/
 354             q
 355           }
 356           /^X\(\/\).*/{
 357             s//\1/
 358             q
 359           }
 360           s/.*/./; q'`
 361       test -d "$as_dir" && break
 362     done
 363     test -z "$as_dirs" || eval "mkdir $as_dirs"
 364   } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
 365 
 366 
 367 } # as_fn_mkdir_p
 368 
 369 # as_fn_executable_p FILE
 370 # -----------------------
 371 # Test if FILE is an executable regular file.
 372 as_fn_executable_p ()
 373 {
 374   test -f "$1" && test -x "$1"
 375 } # as_fn_executable_p
 376 # as_fn_append VAR VALUE
 377 # ----------------------
 378 # Append the text in VALUE to the end of the definition contained in VAR. Take
 379 # advantage of any shell optimizations that allow amortized linear growth over
 380 # repeated appends, instead of the typical quadratic growth present in naive
 381 # implementations.
 382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
 383   eval 'as_fn_append ()
 384   {
 385     eval $1+=\$2
 386   }'
 387 else
 388   as_fn_append ()
 389   {
 390     eval $1=\$$1\$2
 391   }
 392 fi # as_fn_append
 393 
 394 # as_fn_arith ARG...
 395 # ------------------
 396 # Perform arithmetic evaluation on the ARGs, and store the result in the
 397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
 398 # must be portable across $(()) and expr.
 399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
 400   eval 'as_fn_arith ()
 401   {
 402     as_val=$(( $* ))
 403   }'
 404 else
 405   as_fn_arith ()
 406   {
 407     as_val=`expr "$@" || test $? -eq 1`
 408   }
 409 fi # as_fn_arith
 410 
 411 
 412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 413 # ----------------------------------------
 414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
 416 # script with STATUS, using 1 if that was 0.
 417 as_fn_error ()
 418 {
 419   as_status=$1; test $as_status -eq 0 && as_status=1
 420   if test "$4"; then
 421     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 422     $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
 423   fi
 424   $as_echo "$as_me: error: $2" >&2
 425   as_fn_exit $as_status
 426 } # as_fn_error
 427 
 428 if expr a : '\(a\)' >/dev/null 2>&1 &&
 429    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 430   as_expr=expr
 431 else
 432   as_expr=false
 433 fi
 434 
 435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 436   as_basename=basename
 437 else
 438   as_basename=false
 439 fi
 440 
 441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 442   as_dirname=dirname
 443 else
 444   as_dirname=false
 445 fi
 446 
 447 as_me=`$as_basename -- "$0" ||
 448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 449          X"$0" : 'X\(//\)$' \| \
 450          X"$0" : 'X\(/\)' \| . 2>/dev/null ||
 451 $as_echo X/"$0" |
 452     sed '/^.*\/\([^/][^/]*\)\/*$/{
 453             s//\1/
 454             q
 455           }
 456           /^X\/\(\/\/\)$/{
 457             s//\1/
 458             q
 459           }
 460           /^X\/\(\/\).*/{
 461             s//\1/
 462             q
 463           }
 464           s/.*/./; q'`
 465 
 466 # Avoid depending upon Character Ranges.
 467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 470 as_cr_digits='0123456789'
 471 as_cr_alnum=$as_cr_Letters$as_cr_digits
 472 
 473 
 474   as_lineno_1=$LINENO as_lineno_1a=$LINENO
 475   as_lineno_2=$LINENO as_lineno_2a=$LINENO
 476   eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
 477   test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
 478   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 479   sed -n '
 480     p
 481     /[$]LINENO/=
 482   ' <$as_myself |
 483     sed '
 484       s/[$]LINENO.*/&-/
 485       t lineno
 486       b
 487       :lineno
 488       N
 489       :loop
 490       s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
 491       t loop
 492       s/-\n.*//
 493     ' >$as_me.lineno &&
 494   chmod +x "$as_me.lineno" ||
 495     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 496 
 497   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
 498   # already done that, so ensure we don't try to do so again and fall
 499   # in an infinite loop.  This has already happened in practice.
 500   _as_can_reexec=no; export _as_can_reexec
 501   # Don't try to exec as it changes $[0], causing all sort of problems
 502   # (the dirname of $[0] is not the place where we might find the
 503   # original and so on.  Autoconf is especially sensitive to this).
 504   . "./$as_me.lineno"
 505   # Exit status is that of the last command.
 506   exit
 507 }
 508 
 509 ECHO_C= ECHO_N= ECHO_T=
 510 case `echo -n x` in #(((((
 511 -n*)
 512   case `echo 'xy\c'` in
 513   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 514   xy)  ECHO_C='\c';;
 515   *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
 516        ECHO_T=' ';;
 517   esac;;
 518 *)
 519   ECHO_N='-n';;
 520 esac
 521 
 522 rm -f conf$$ conf$$.exe conf$$.file
 523 if test -d conf$$.dir; then
 524   rm -f conf$$.dir/conf$$.file
 525 else
 526   rm -f conf$$.dir
 527   mkdir conf$$.dir 2>/dev/null
 528 fi
 529 if (echo >conf$$.file) 2>/dev/null; then
 530   if ln -s conf$$.file conf$$ 2>/dev/null; then
 531     as_ln_s='ln -s'
 532     # ... but there are two gotchas:
 533     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
 534     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
 535     # In both cases, we have to default to `cp -pR'.
 536     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
 537       as_ln_s='cp -pR'
 538   elif ln conf$$.file conf$$ 2>/dev/null; then
 539     as_ln_s=ln
 540   else
 541     as_ln_s='cp -pR'
 542   fi
 543 else
 544   as_ln_s='cp -pR'
 545 fi
 546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 547 rmdir conf$$.dir 2>/dev/null
 548 
 549 if mkdir -p . 2>/dev/null; then
 550   as_mkdir_p='mkdir -p "$as_dir"'
 551 else
 552   test -d ./-p && rmdir ./-p
 553   as_mkdir_p=false
 554 fi
 555 
 556 as_test_x='test -x'
 557 as_executable_p=as_fn_executable_p
 558 
 559 # Sed expression to map a string onto a valid CPP name.
 560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 561 
 562 # Sed expression to map a string onto a valid variable name.
 563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 564 
 565 
 566 test -n "$DJDIR" || exec 7<&0 </dev/null
 567 exec 6>&1
 568 
 569 # Name of the host.
 570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 571 # so uname gets run too.
 572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 573 
 574 #
 575 # Initializations.
 576 #
 577 ac_default_prefix=/usr/local
 578 ac_clean_files=
 579 ac_config_libobj_dir=.
 580 LIBOBJS=
 581 cross_compiling=no
 582 subdirs=
 583 MFLAGS=
 584 MAKEFLAGS=
 585 
 586 # Identity of this package.
 587 PACKAGE_NAME='OpenJDK'
 588 PACKAGE_TARNAME='openjdk'
 589 PACKAGE_VERSION='jdk9'
 590 PACKAGE_STRING='OpenJDK jdk9'
 591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
 592 PACKAGE_URL='http://openjdk.java.net'
 593 
 594 # Factoring default headers for most tests.
 595 ac_includes_default="\
 596 #include <stdio.h>
 597 #ifdef HAVE_SYS_TYPES_H
 598 # include <sys/types.h>
 599 #endif
 600 #ifdef HAVE_SYS_STAT_H
 601 # include <sys/stat.h>
 602 #endif
 603 #ifdef STDC_HEADERS
 604 # include <stdlib.h>
 605 # include <stddef.h>
 606 #else
 607 # ifdef HAVE_STDLIB_H
 608 #  include <stdlib.h>
 609 # endif
 610 #endif
 611 #ifdef HAVE_STRING_H
 612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 613 #  include <memory.h>
 614 # endif
 615 # include <string.h>
 616 #endif
 617 #ifdef HAVE_STRINGS_H
 618 # include <strings.h>
 619 #endif
 620 #ifdef HAVE_INTTYPES_H
 621 # include <inttypes.h>
 622 #endif
 623 #ifdef HAVE_STDINT_H
 624 # include <stdint.h>
 625 #endif
 626 #ifdef HAVE_UNISTD_H
 627 # include <unistd.h>
 628 #endif"
 629 
 630 ac_subst_vars='LTLIBOBJS
 631 LIBOBJS
 632 CFLAGS_CCACHE
 633 CCACHE
 634 USE_PRECOMPILED_HEADER
 635 BUILD_ICECC
 636 ICECC
 637 ICECC_WRAPPER
 638 ICECC_CREATE_ENV
 639 ICECC_CMD
 640 ENABLE_JAVAC_SERVER
 641 ENABLE_SJAVAC
 642 SJAVAC_SERVER_JAVA_FLAGS
 643 SJAVAC_SERVER_JAVA
 644 JAVA_TOOL_FLAGS_SMALL
 645 JAVA_FLAGS_SMALL
 646 JAVA_FLAGS_JAVAC
 647 JAVA_FLAGS_BIG
 648 JAVA_FLAGS
 649 TEST_JOBS
 650 JOBS
 651 MEMORY_SIZE
 652 NUM_CORES
 653 ENABLE_INTREE_EC
 654 LIBZIP_CAN_USE_MMAP
 655 LIBDL
 656 LIBM
 657 USE_EXTERNAL_LCMS
 658 LCMS_LIBS
 659 LCMS_CFLAGS
 660 USE_EXTERNAL_LIBZ
 661 USE_EXTERNAL_LIBPNG
 662 PNG_LIBS
 663 PNG_CFLAGS
 664 USE_EXTERNAL_LIBGIF
 665 USE_EXTERNAL_LIBJPEG
 666 LLVM_LIBS
 667 LLVM_LDFLAGS
 668 LLVM_CFLAGS
 669 LLVM_CONFIG
 670 LIBFFI_LIBS
 671 LIBFFI_CFLAGS
 672 ALSA_LIBS
 673 ALSA_CFLAGS
 674 FREETYPE_BUNDLE_LIB_PATH
 675 FREETYPE_LIBS
 676 FREETYPE_CFLAGS
 677 CUPS_CFLAGS
 678 X_EXTRA_LIBS
 679 X_LIBS
 680 X_PRE_LIBS
 681 X_CFLAGS
 682 XMKMF
 683 MSVCP_DLL
 684 MSVCR_DLL
 685 LIBCXX
 686 STATIC_CXX_SETTING
 687 FIXPATH_DETACH_FLAG
 688 FIXPATH
 689 VALID_JVM_FEATURES
 690 JVM_FEATURES_custom
 691 JVM_FEATURES_zeroshark
 692 JVM_FEATURES_zero
 693 JVM_FEATURES_minimal
 694 JVM_FEATURES_core
 695 JVM_FEATURES_client
 696 JVM_FEATURES_server
 697 INCLUDE_DTRACE
 698 GCOV_ENABLED
 699 STRIP_POLICY
 700 DEBUG_BINARIES
 701 ZIP_EXTERNAL_DEBUG_SYMBOLS
 702 COPY_DEBUG_SYMBOLS
 703 COMPILE_WITH_DEBUG_SYMBOLS
 704 CFLAGS_WARNINGS_ARE_ERRORS
 705 BUILD_CC_DISABLE_WARNING_PREFIX
 706 DISABLE_WARNING_PREFIX
 707 HOTSPOT_SET_WARNINGS_AS_ERRORS
 708 WARNINGS_AS_ERRORS
 709 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 710 ZERO_ARCHFLAG
 711 LDFLAGS_TESTEXE
 712 LDFLAGS_TESTLIB
 713 CXXFLAGS_TESTEXE
 714 CXXFLAGS_TESTLIB
 715 CFLAGS_TESTEXE
 716 CFLAGS_TESTLIB
 717 OPENJDK_BUILD_JVM_LIBS
 718 OPENJDK_BUILD_JVM_ASFLAGS
 719 OPENJDK_BUILD_JVM_LDFLAGS
 720 OPENJDK_BUILD_JVM_CFLAGS
 721 OPENJDK_BUILD_LDFLAGS_HASH_STYLE
 722 OPENJDK_BUILD_LDFLAGS_CXX_JDK
 723 OPENJDK_BUILD_JDKEXE_LIBS
 724 OPENJDK_BUILD_JDKLIB_LIBS
 725 OPENJDK_BUILD_LDFLAGS_JDKEXE
 726 OPENJDK_BUILD_LDFLAGS_JDKLIB
 727 OPENJDK_BUILD_CXXFLAGS_JDKEXE
 728 OPENJDK_BUILD_CXXFLAGS_JDKLIB
 729 OPENJDK_BUILD_CFLAGS_JDKEXE
 730 OPENJDK_BUILD_CFLAGS_JDKLIB
 731 OPENJDK_BUILD_CXXSTD_CXXFLAG
 732 JVM_LIBS
 733 JVM_ASFLAGS
 734 JVM_LDFLAGS
 735 JVM_CFLAGS
 736 LDFLAGS_HASH_STYLE
 737 LDFLAGS_CXX_JDK
 738 JDKEXE_LIBS
 739 JDKLIB_LIBS
 740 LDFLAGS_JDKEXE
 741 LDFLAGS_JDKLIB
 742 CXXFLAGS_JDKEXE
 743 CXXFLAGS_JDKLIB
 744 CFLAGS_JDKEXE
 745 CFLAGS_JDKLIB
 746 MACOSX_VERSION_MIN
 747 NO_LIFETIME_DSE_CFLAG
 748 NO_NULL_POINTER_CHECK_CFLAG
 749 CXXSTD_CXXFLAG
 750 CXX_O_FLAG_SIZE
 751 CXX_O_FLAG_NONE
 752 CXX_O_FLAG_DEBUG
 753 CXX_O_FLAG_NORM
 754 CXX_O_FLAG_HI
 755 CXX_O_FLAG_HIGHEST
 756 CXX_O_FLAG_HIGHEST_JVM
 757 C_O_FLAG_SIZE
 758 C_O_FLAG_NONE
 759 C_O_FLAG_DEBUG
 760 C_O_FLAG_NORM
 761 C_O_FLAG_HI
 762 C_O_FLAG_HIGHEST
 763 C_O_FLAG_HIGHEST_JVM
 764 JVM_CFLAGS_SYMBOLS
 765 CXXFLAGS_DEBUG_SYMBOLS
 766 CFLAGS_DEBUG_SYMBOLS
 767 CXX_FLAG_DEPS
 768 C_FLAG_DEPS
 769 SHARED_LIBRARY_FLAGS
 770 SET_SHARED_LIBRARY_MAPFILE
 771 SET_SHARED_LIBRARY_NAME
 772 SET_SHARED_LIBRARY_ORIGIN
 773 SET_EXECUTABLE_ORIGIN
 774 CXX_FLAG_REORDER
 775 C_FLAG_REORDER
 776 JVM_RCFLAGS
 777 RC_FLAGS
 778 AR_OUT_OPTION
 779 LD_OUT_OPTION
 780 EXE_OUT_OPTION
 781 CC_OUT_OPTION
 782 STRIPFLAGS
 783 ARFLAGS
 784 COMPILER_BINDCMD_FILE_FLAG
 785 COMPILER_COMMAND_FILE_FLAG
 786 COMPILER_TARGET_BITS_FLAG
 787 JT_HOME
 788 JTREGEXE
 789 HOTSPOT_TOOLCHAIN_TYPE
 790 USING_BROKEN_SUSE_LD
 791 PACKAGE_PATH
 792 USE_CLANG
 793 HOTSPOT_LD
 794 HOTSPOT_CXX
 795 HOTSPOT_RC
 796 HOTSPOT_MT
 797 BUILD_AS
 798 BUILD_LDCXX
 799 BUILD_LD
 800 BUILD_STRIP
 801 BUILD_OBJCOPY
 802 BUILD_AR
 803 BUILD_NM
 804 BUILD_CXX
 805 BUILD_CC
 806 BUILD_SYSROOT_LDFLAGS
 807 BUILD_SYSROOT_CFLAGS
 808 ac_ct_OBJDUMP
 809 OBJDUMP
 810 ac_ct_OBJCOPY
 811 OBJCOPY
 812 ac_ct_NM
 813 ac_ct_STRIP
 814 GNM
 815 NM
 816 STRIP
 817 MSBUILD
 818 DUMPBIN
 819 RC
 820 MT
 821 LIPO
 822 ac_ct_AR
 823 AR
 824 AS
 825 LDCXX
 826 LD
 827 CXXCPP
 828 CPP
 829 CXX_VERSION_NUMBER
 830 CC_VERSION_NUMBER
 831 ac_ct_CXX
 832 CXXFLAGS
 833 CXX
 834 TOOLCHAIN_PATH_CXX
 835 POTENTIAL_CXX
 836 OBJEXT
 837 EXEEXT
 838 ac_ct_CC
 839 CPPFLAGS
 840 LDFLAGS
 841 CFLAGS
 842 CC
 843 TOOLCHAIN_PATH_CC
 844 POTENTIAL_CC
 845 TOOLCHAIN_VERSION
 846 VS_LIB
 847 VS_INCLUDE
 848 VS_PATH
 849 CYGWIN_LINK
 850 SYSROOT_LDFLAGS
 851 SYSROOT_CFLAGS
 852 EXTRA_LDFLAGS
 853 EXTRA_CXXFLAGS
 854 EXTRA_CFLAGS
 855 LEGACY_EXTRA_LDFLAGS
 856 LEGACY_EXTRA_CXXFLAGS
 857 LEGACY_EXTRA_CFLAGS
 858 EXE_SUFFIX
 859 OBJ_SUFFIX
 860 STATIC_LIBRARY
 861 SHARED_LIBRARY
 862 STATIC_LIBRARY_SUFFIX
 863 SHARED_LIBRARY_SUFFIX
 864 LIBRARY_PREFIX
 865 TOOLCHAIN_TYPE
 866 STATIC_BUILD
 867 IMPORT_MODULES_MAKE
 868 IMPORT_MODULES_SRC
 869 IMPORT_MODULES_CONF
 870 IMPORT_MODULES_LIBS
 871 IMPORT_MODULES_CMDS
 872 IMPORT_MODULES_CLASSES
 873 BUILD_HOTSPOT
 874 HOTSPOT_DIST
 875 BUILD_OUTPUT
 876 JDK_TOPDIR
 877 NASHORN_TOPDIR
 878 HOTSPOT_TOPDIR
 879 JAXWS_TOPDIR
 880 JAXP_TOPDIR
 881 CORBA_TOPDIR
 882 LANGTOOLS_TOPDIR
 883 BUILD_JDK
 884 CREATE_BUILDJDK
 885 BOOT_JDK_BITS
 886 JAVAC_FLAGS
 887 BOOT_JDK_MODULAR
 888 BOOT_JDK_SOURCETARGET
 889 JARSIGNER
 890 JAR
 891 JAVAH
 892 JAVAC
 893 JAVA
 894 BOOT_JDK
 895 JAVA_CHECK
 896 JAVAC_CHECK
 897 VERSION_IS_GA
 898 VERSION_SHORT
 899 VERSION_STRING
 900 VERSION_NUMBER_FOUR_POSITIONS
 901 VERSION_NUMBER
 902 VERSION_OPT
 903 VERSION_BUILD
 904 VERSION_PRE
 905 VERSION_PATCH
 906 VERSION_SECURITY
 907 VERSION_MINOR
 908 VERSION_MAJOR
 909 MACOSX_BUNDLE_ID_BASE
 910 MACOSX_BUNDLE_NAME_BASE
 911 HOTSPOT_VM_DISTRO
 912 COMPANY_NAME
 913 JDK_RC_PLATFORM_NAME
 914 PRODUCT_SUFFIX
 915 PRODUCT_NAME
 916 LAUNCHER_NAME
 917 JLINK_KEEP_PACKAGED_MODULES
 918 COPYRIGHT_YEAR
 919 COMPRESS_JARS
 920 INCLUDE_SA
 921 UNLIMITED_CRYPTO
 922 CACERTS_FILE
 923 BUILD_HEADLESS
 924 SUPPORT_HEADFUL
 925 SUPPORT_HEADLESS
 926 DEFAULT_MAKE_TARGET
 927 OS_VERSION_MICRO
 928 OS_VERSION_MINOR
 929 OS_VERSION_MAJOR
 930 PKG_CONFIG
 931 BASH_ARGS
 932 SETFILE
 933 CODESIGN
 934 XATTR
 935 DSYMUTIL
 936 IS_GNU_TIME
 937 PATCH
 938 DTRACE
 939 TIME
 940 STAT
 941 HG
 942 READELF
 943 OTOOL
 944 LDD
 945 ZIP
 946 UNZIP
 947 FIND_DELETE
 948 OUTPUT_SYNC
 949 OUTPUT_SYNC_SUPPORTED
 950 CHECK_TOOLSDIR_MAKE
 951 CHECK_TOOLSDIR_GMAKE
 952 CHECK_MAKE
 953 CHECK_GMAKE
 954 MAKE
 955 PKGHANDLER
 956 CONFIGURESUPPORT_OUTPUTDIR
 957 OUTPUT_ROOT
 958 CONF_NAME
 959 SPEC
 960 SDKROOT
 961 XCODEBUILD
 962 VALID_JVM_VARIANTS
 963 JVM_VARIANTS
 964 DEBUG_LEVEL
 965 HOTSPOT_DEBUG_LEVEL
 966 JDK_VARIANT
 967 SET_OPENJDK
 968 USERNAME
 969 CANONICAL_TOPDIR
 970 ORIGINAL_TOPDIR
 971 TOPDIR
 972 PATH_SEP
 973 ZERO_ARCHDEF
 974 HOTSPOT_BUILD_CPU_DEFINE
 975 HOTSPOT_BUILD_CPU_ARCH
 976 HOTSPOT_BUILD_CPU
 977 HOTSPOT_BUILD_OS_TYPE
 978 HOTSPOT_BUILD_OS
 979 OPENJDK_BUILD_OS_EXPORT_DIR
 980 OPENJDK_BUILD_CPU_JLI_CFLAGS
 981 OPENJDK_BUILD_CPU_OSARCH
 982 OPENJDK_BUILD_CPU_ISADIR
 983 OPENJDK_BUILD_CPU_LIBDIR
 984 OPENJDK_BUILD_CPU_LEGACY_LIB
 985 OPENJDK_BUILD_CPU_LEGACY
 986 HOTSPOT_TARGET_CPU_DEFINE
 987 HOTSPOT_TARGET_CPU_ARCH
 988 HOTSPOT_TARGET_CPU
 989 HOTSPOT_TARGET_OS_TYPE
 990 HOTSPOT_TARGET_OS
 991 DEFINE_CROSS_COMPILE_ARCH
 992 LP64
 993 OPENJDK_TARGET_OS_EXPORT_DIR
 994 OPENJDK_TARGET_CPU_JLI_CFLAGS
 995 OPENJDK_TARGET_CPU_OSARCH
 996 OPENJDK_TARGET_CPU_ISADIR
 997 OPENJDK_TARGET_CPU_LIBDIR
 998 OPENJDK_TARGET_CPU_LEGACY_LIB
 999 OPENJDK_TARGET_CPU_LEGACY
1000 REQUIRED_OS_VERSION
1001 REQUIRED_OS_NAME
1002 COMPILE_TYPE
1003 OPENJDK_TARGET_CPU_ENDIAN
1004 OPENJDK_TARGET_CPU_BITS
1005 OPENJDK_TARGET_CPU_ARCH
1006 OPENJDK_TARGET_CPU
1007 OPENJDK_TARGET_OS_ENV
1008 OPENJDK_TARGET_OS_TYPE
1009 OPENJDK_TARGET_OS
1010 OPENJDK_BUILD_CPU_ENDIAN
1011 OPENJDK_BUILD_CPU_BITS
1012 OPENJDK_BUILD_CPU_ARCH
1013 OPENJDK_BUILD_CPU
1014 OPENJDK_BUILD_OS_ENV
1015 OPENJDK_BUILD_OS_TYPE
1016 OPENJDK_BUILD_OS
1017 OPENJDK_BUILD_AUTOCONF_NAME
1018 OPENJDK_TARGET_AUTOCONF_NAME
1019 target_os
1020 target_vendor
1021 target_cpu
1022 target
1023 host_os
1024 host_vendor
1025 host_cpu
1026 host
1027 build_os
1028 build_vendor
1029 build_cpu
1030 build
1031 NICE
1032 CPIO
1033 DF
1034 READLINK
1035 CYGPATH
1036 SED
1037 FGREP
1038 EGREP
1039 GREP
1040 AWK
1041 XARGS
1042 WHICH
1043 WC
1044 UNIQ
1045 UNAME
1046 TR
1047 TOUCH
1048 TEE
1049 TAR
1050 TAIL
1051 SORT
1052 SH
1053 RMDIR
1054 RM
1055 PRINTF
1056 NAWK
1057 MV
1058 MKTEMP
1059 MKDIR
1060 LS
1061 LN
1062 HEAD
1063 FIND
1064 FILE
1065 EXPR
1066 ECHO
1067 DIRNAME
1068 DIFF
1069 DATE
1070 CUT
1071 CP
1072 COMM
1073 CMP
1074 CHMOD
1075 CAT
1076 BASH
1077 BASENAME
1078 DATE_WHEN_CONFIGURED
1079 ORIGINAL_PATH
1080 CONFIGURE_COMMAND_LINE
1081 target_alias
1082 host_alias
1083 build_alias
1084 LIBS
1085 ECHO_T
1086 ECHO_N
1087 ECHO_C
1088 DEFS
1089 mandir
1090 localedir
1091 libdir
1092 psdir
1093 pdfdir
1094 dvidir
1095 htmldir
1096 infodir
1097 docdir
1098 oldincludedir
1099 includedir
1100 localstatedir
1101 sharedstatedir
1102 sysconfdir
1103 datadir
1104 datarootdir
1105 libexecdir
1106 sbindir
1107 bindir
1108 program_transform_name
1109 prefix
1110 exec_prefix
1111 PACKAGE_URL
1112 PACKAGE_BUGREPORT
1113 PACKAGE_STRING
1114 PACKAGE_VERSION
1115 PACKAGE_TARNAME
1116 PACKAGE_NAME
1117 PATH_SEPARATOR
1118 SHELL'
1119 ac_subst_files=''
1120 ac_user_opts='
1121 enable_option_checking
1122 with_target_bits
1123 enable_openjdk_only
1124 with_custom_make_dir
1125 with_jdk_variant
1126 enable_debug
1127 with_debug_level
1128 with_jvm_variants
1129 with_devkit
1130 with_sys_root
1131 with_sysroot
1132 with_tools_dir
1133 with_toolchain_path
1134 with_extra_path
1135 with_sdk_name
1136 with_conf_name
1137 with_output_sync
1138 with_default_make_target
1139 enable_headful
1140 with_cacerts_file
1141 enable_unlimited_crypto
1142 with_copyright_year
1143 enable_keep_packaged_modules
1144 with_milestone
1145 with_update_version
1146 with_user_release_suffix
1147 with_build_number
1148 with_version_string
1149 with_version_pre
1150 with_version_opt
1151 with_version_build
1152 with_version_major
1153 with_version_minor
1154 with_version_security
1155 with_version_patch
1156 with_boot_jdk
1157 with_build_jdk
1158 with_add_source_root
1159 with_override_source_root
1160 with_adds_and_overrides
1161 with_override_langtools
1162 with_override_corba
1163 with_override_jaxp
1164 with_override_jaxws
1165 with_override_hotspot
1166 with_override_nashorn
1167 with_override_jdk
1168 with_import_hotspot
1169 with_import_modules
1170 enable_static_build
1171 with_toolchain_type
1172 with_extra_cflags
1173 with_extra_cxxflags
1174 with_extra_ldflags
1175 with_toolchain_version
1176 with_build_devkit
1177 with_jtreg
1178 enable_warnings_as_errors
1179 with_native_debug_symbols
1180 enable_debug_symbols
1181 enable_zip_debug_info
1182 enable_native_coverage
1183 enable_dtrace
1184 with_jvm_features
1185 with_jvm_interpreter
1186 with_stdc__lib
1187 with_msvcr_dll
1188 with_msvcp_dll
1189 with_x
1190 with_cups
1191 with_cups_include
1192 with_freetype
1193 with_freetype_include
1194 with_freetype_lib
1195 with_freetype_src
1196 enable_freetype_bundling
1197 with_alsa
1198 with_alsa_include
1199 with_alsa_lib
1200 with_libffi
1201 with_libffi_include
1202 with_libffi_lib
1203 with_libjpeg
1204 with_giflib
1205 with_libpng
1206 with_zlib
1207 with_lcms
1208 with_dxsdk
1209 with_dxsdk_lib
1210 with_dxsdk_include
1211 with_num_cores
1212 with_memory_size
1213 with_jobs
1214 with_test_jobs
1215 with_boot_jdk_jvmargs
1216 with_sjavac_server_java
1217 enable_sjavac
1218 enable_javac_server
1219 enable_icecc
1220 enable_precompiled_headers
1221 enable_ccache
1222 with_ccache_dir
1223 '
1224       ac_precious_vars='build_alias
1225 host_alias
1226 target_alias
1227 BASENAME
1228 BASH
1229 CAT
1230 CHMOD
1231 CMP
1232 COMM
1233 CP
1234 CUT
1235 DATE
1236 DIFF
1237 DIRNAME
1238 ECHO
1239 EXPR
1240 FILE
1241 FIND
1242 HEAD
1243 LN
1244 LS
1245 MKDIR
1246 MKTEMP
1247 MV
1248 NAWK
1249 PRINTF
1250 RM
1251 RMDIR
1252 SH
1253 SORT
1254 TAIL
1255 TAR
1256 TEE
1257 TOUCH
1258 TR
1259 UNAME
1260 UNIQ
1261 WC
1262 WHICH
1263 XARGS
1264 AWK
1265 GREP
1266 EGREP
1267 FGREP
1268 SED
1269 CYGPATH
1270 READLINK
1271 DF
1272 CPIO
1273 NICE
1274 MAKE
1275 UNZIP
1276 ZIP
1277 LDD
1278 OTOOL
1279 READELF
1280 HG
1281 STAT
1282 TIME
1283 DTRACE
1284 PATCH
1285 DSYMUTIL
1286 XATTR
1287 CODESIGN
1288 SETFILE
1289 PKG_CONFIG
1290 JAVA
1291 JAVAC
1292 JAVAH
1293 JAR
1294 JARSIGNER
1295 CC
1296 CFLAGS
1297 LDFLAGS
1298 LIBS
1299 CPPFLAGS
1300 CXX
1301 CXXFLAGS
1302 CCC
1303 CPP
1304 CXXCPP
1305 AS
1306 AR
1307 LIPO
1308 STRIP
1309 NM
1310 GNM
1311 OBJCOPY
1312 OBJDUMP
1313 BUILD_CC
1314 BUILD_CXX
1315 BUILD_NM
1316 BUILD_AR
1317 BUILD_OBJCOPY
1318 BUILD_STRIP
1319 JTREGEXE
1320 XMKMF
1321 FREETYPE_CFLAGS
1322 FREETYPE_LIBS
1323 ALSA_CFLAGS
1324 ALSA_LIBS
1325 LIBFFI_CFLAGS
1326 LIBFFI_LIBS
1327 PNG_CFLAGS
1328 PNG_LIBS
1329 LCMS_CFLAGS
1330 LCMS_LIBS
1331 ICECC_CMD
1332 ICECC_CREATE_ENV
1333 ICECC_WRAPPER
1334 CCACHE'
1335 
1336 
1337 # Initialize some variables set by options.
1338 ac_init_help=
1339 ac_init_version=false
1340 ac_unrecognized_opts=
1341 ac_unrecognized_sep=
1342 # The variables have the same names as the options, with
1343 # dashes changed to underlines.
1344 cache_file=/dev/null
1345 exec_prefix=NONE
1346 no_create=
1347 no_recursion=
1348 prefix=NONE
1349 program_prefix=NONE
1350 program_suffix=NONE
1351 program_transform_name=s,x,x,
1352 silent=
1353 site=
1354 srcdir=
1355 verbose=
1356 x_includes=NONE
1357 x_libraries=NONE
1358 
1359 # Installation directory options.
1360 # These are left unexpanded so users can "make install exec_prefix=/foo"
1361 # and all the variables that are supposed to be based on exec_prefix
1362 # by default will actually change.
1363 # Use braces instead of parens because sh, perl, etc. also accept them.
1364 # (The list follows the same order as the GNU Coding Standards.)
1365 bindir='${exec_prefix}/bin'
1366 sbindir='${exec_prefix}/sbin'
1367 libexecdir='${exec_prefix}/libexec'
1368 datarootdir='${prefix}/share'
1369 datadir='${datarootdir}'
1370 sysconfdir='${prefix}/etc'
1371 sharedstatedir='${prefix}/com'
1372 localstatedir='${prefix}/var'
1373 includedir='${prefix}/include'
1374 oldincludedir='/usr/include'
1375 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1376 infodir='${datarootdir}/info'
1377 htmldir='${docdir}'
1378 dvidir='${docdir}'
1379 pdfdir='${docdir}'
1380 psdir='${docdir}'
1381 libdir='${exec_prefix}/lib'
1382 localedir='${datarootdir}/locale'
1383 mandir='${datarootdir}/man'
1384 
1385 ac_prev=
1386 ac_dashdash=
1387 for ac_option
1388 do
1389   # If the previous option needs an argument, assign it.
1390   if test -n "$ac_prev"; then
1391     eval $ac_prev=\$ac_option
1392     ac_prev=
1393     continue
1394   fi
1395 
1396   case $ac_option in
1397   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1398   *=)   ac_optarg= ;;
1399   *)    ac_optarg=yes ;;
1400   esac
1401 
1402   # Accept the important Cygnus configure options, so we can diagnose typos.
1403 
1404   case $ac_dashdash$ac_option in
1405   --)
1406     ac_dashdash=yes ;;
1407 
1408   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1409     ac_prev=bindir ;;
1410   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1411     bindir=$ac_optarg ;;
1412 
1413   -build | --build | --buil | --bui | --bu)
1414     ac_prev=build_alias ;;
1415   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1416     build_alias=$ac_optarg ;;
1417 
1418   -cache-file | --cache-file | --cache-fil | --cache-fi \
1419   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1420     ac_prev=cache_file ;;
1421   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1422   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1423     cache_file=$ac_optarg ;;
1424 
1425   --config-cache | -C)
1426     cache_file=config.cache ;;
1427 
1428   -datadir | --datadir | --datadi | --datad)
1429     ac_prev=datadir ;;
1430   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1431     datadir=$ac_optarg ;;
1432 
1433   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1434   | --dataroo | --dataro | --datar)
1435     ac_prev=datarootdir ;;
1436   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1437   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1438     datarootdir=$ac_optarg ;;
1439 
1440   -disable-* | --disable-*)
1441     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1442     # Reject names that are not valid shell variable names.
1443     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1444       as_fn_error $? "invalid feature name: $ac_useropt"
1445     ac_useropt_orig=$ac_useropt
1446     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1447     case $ac_user_opts in
1448       *"
1449 "enable_$ac_useropt"
1450 "*) ;;
1451       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1452          ac_unrecognized_sep=', ';;
1453     esac
1454     eval enable_$ac_useropt=no ;;
1455 
1456   -docdir | --docdir | --docdi | --doc | --do)
1457     ac_prev=docdir ;;
1458   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1459     docdir=$ac_optarg ;;
1460 
1461   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1462     ac_prev=dvidir ;;
1463   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1464     dvidir=$ac_optarg ;;
1465 
1466   -enable-* | --enable-*)
1467     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1468     # Reject names that are not valid shell variable names.
1469     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1470       as_fn_error $? "invalid feature name: $ac_useropt"
1471     ac_useropt_orig=$ac_useropt
1472     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1473     case $ac_user_opts in
1474       *"
1475 "enable_$ac_useropt"
1476 "*) ;;
1477       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1478          ac_unrecognized_sep=', ';;
1479     esac
1480     eval enable_$ac_useropt=\$ac_optarg ;;
1481 
1482   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1483   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1484   | --exec | --exe | --ex)
1485     ac_prev=exec_prefix ;;
1486   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1487   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1488   | --exec=* | --exe=* | --ex=*)
1489     exec_prefix=$ac_optarg ;;
1490 
1491   -gas | --gas | --ga | --g)
1492     # Obsolete; use --with-gas.
1493     with_gas=yes ;;
1494 
1495   -help | --help | --hel | --he | -h)
1496     ac_init_help=long ;;
1497   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1498     ac_init_help=recursive ;;
1499   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1500     ac_init_help=short ;;
1501 
1502   -host | --host | --hos | --ho)
1503     ac_prev=host_alias ;;
1504   -host=* | --host=* | --hos=* | --ho=*)
1505     host_alias=$ac_optarg ;;
1506 
1507   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1508     ac_prev=htmldir ;;
1509   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1510   | --ht=*)
1511     htmldir=$ac_optarg ;;
1512 
1513   -includedir | --includedir | --includedi | --included | --include \
1514   | --includ | --inclu | --incl | --inc)
1515     ac_prev=includedir ;;
1516   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1517   | --includ=* | --inclu=* | --incl=* | --inc=*)
1518     includedir=$ac_optarg ;;
1519 
1520   -infodir | --infodir | --infodi | --infod | --info | --inf)
1521     ac_prev=infodir ;;
1522   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1523     infodir=$ac_optarg ;;
1524 
1525   -libdir | --libdir | --libdi | --libd)
1526     ac_prev=libdir ;;
1527   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1528     libdir=$ac_optarg ;;
1529 
1530   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1531   | --libexe | --libex | --libe)
1532     ac_prev=libexecdir ;;
1533   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1534   | --libexe=* | --libex=* | --libe=*)
1535     libexecdir=$ac_optarg ;;
1536 
1537   -localedir | --localedir | --localedi | --localed | --locale)
1538     ac_prev=localedir ;;
1539   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1540     localedir=$ac_optarg ;;
1541 
1542   -localstatedir | --localstatedir | --localstatedi | --localstated \
1543   | --localstate | --localstat | --localsta | --localst | --locals)
1544     ac_prev=localstatedir ;;
1545   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1546   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1547     localstatedir=$ac_optarg ;;
1548 
1549   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1550     ac_prev=mandir ;;
1551   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1552     mandir=$ac_optarg ;;
1553 
1554   -nfp | --nfp | --nf)
1555     # Obsolete; use --without-fp.
1556     with_fp=no ;;
1557 
1558   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1559   | --no-cr | --no-c | -n)
1560     no_create=yes ;;
1561 
1562   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1563   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1564     no_recursion=yes ;;
1565 
1566   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1567   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1568   | --oldin | --oldi | --old | --ol | --o)
1569     ac_prev=oldincludedir ;;
1570   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1571   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1572   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1573     oldincludedir=$ac_optarg ;;
1574 
1575   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1576     ac_prev=prefix ;;
1577   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1578     prefix=$ac_optarg ;;
1579 
1580   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1581   | --program-pre | --program-pr | --program-p)
1582     ac_prev=program_prefix ;;
1583   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1584   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1585     program_prefix=$ac_optarg ;;
1586 
1587   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1588   | --program-suf | --program-su | --program-s)
1589     ac_prev=program_suffix ;;
1590   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1591   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1592     program_suffix=$ac_optarg ;;
1593 
1594   -program-transform-name | --program-transform-name \
1595   | --program-transform-nam | --program-transform-na \
1596   | --program-transform-n | --program-transform- \
1597   | --program-transform | --program-transfor \
1598   | --program-transfo | --program-transf \
1599   | --program-trans | --program-tran \
1600   | --progr-tra | --program-tr | --program-t)
1601     ac_prev=program_transform_name ;;
1602   -program-transform-name=* | --program-transform-name=* \
1603   | --program-transform-nam=* | --program-transform-na=* \
1604   | --program-transform-n=* | --program-transform-=* \
1605   | --program-transform=* | --program-transfor=* \
1606   | --program-transfo=* | --program-transf=* \
1607   | --program-trans=* | --program-tran=* \
1608   | --progr-tra=* | --program-tr=* | --program-t=*)
1609     program_transform_name=$ac_optarg ;;
1610 
1611   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1612     ac_prev=pdfdir ;;
1613   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1614     pdfdir=$ac_optarg ;;
1615 
1616   -psdir | --psdir | --psdi | --psd | --ps)
1617     ac_prev=psdir ;;
1618   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1619     psdir=$ac_optarg ;;
1620 
1621   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1622   | -silent | --silent | --silen | --sile | --sil)
1623     silent=yes ;;
1624 
1625   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1626     ac_prev=sbindir ;;
1627   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1628   | --sbi=* | --sb=*)
1629     sbindir=$ac_optarg ;;
1630 
1631   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1632   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1633   | --sharedst | --shareds | --shared | --share | --shar \
1634   | --sha | --sh)
1635     ac_prev=sharedstatedir ;;
1636   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1637   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1638   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1639   | --sha=* | --sh=*)
1640     sharedstatedir=$ac_optarg ;;
1641 
1642   -site | --site | --sit)
1643     ac_prev=site ;;
1644   -site=* | --site=* | --sit=*)
1645     site=$ac_optarg ;;
1646 
1647   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1648     ac_prev=srcdir ;;
1649   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1650     srcdir=$ac_optarg ;;
1651 
1652   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1653   | --syscon | --sysco | --sysc | --sys | --sy)
1654     ac_prev=sysconfdir ;;
1655   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1656   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1657     sysconfdir=$ac_optarg ;;
1658 
1659   -target | --target | --targe | --targ | --tar | --ta | --t)
1660     ac_prev=target_alias ;;
1661   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1662     target_alias=$ac_optarg ;;
1663 
1664   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1665     verbose=yes ;;
1666 
1667   -version | --version | --versio | --versi | --vers | -V)
1668     ac_init_version=: ;;
1669 
1670   -with-* | --with-*)
1671     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1672     # Reject names that are not valid shell variable names.
1673     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1674       as_fn_error $? "invalid package name: $ac_useropt"
1675     ac_useropt_orig=$ac_useropt
1676     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1677     case $ac_user_opts in
1678       *"
1679 "with_$ac_useropt"
1680 "*) ;;
1681       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1682          ac_unrecognized_sep=', ';;
1683     esac
1684     eval with_$ac_useropt=\$ac_optarg ;;
1685 
1686   -without-* | --without-*)
1687     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1688     # Reject names that are not valid shell variable names.
1689     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1690       as_fn_error $? "invalid package name: $ac_useropt"
1691     ac_useropt_orig=$ac_useropt
1692     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1693     case $ac_user_opts in
1694       *"
1695 "with_$ac_useropt"
1696 "*) ;;
1697       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1698          ac_unrecognized_sep=', ';;
1699     esac
1700     eval with_$ac_useropt=no ;;
1701 
1702   --x)
1703     # Obsolete; use --with-x.
1704     with_x=yes ;;
1705 
1706   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1707   | --x-incl | --x-inc | --x-in | --x-i)
1708     ac_prev=x_includes ;;
1709   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1710   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1711     x_includes=$ac_optarg ;;
1712 
1713   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1714   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1715     ac_prev=x_libraries ;;
1716   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1717   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1718     x_libraries=$ac_optarg ;;
1719 
1720   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1721 Try \`$0 --help' for more information"
1722     ;;
1723 
1724   *=*)
1725     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1726     # Reject names that are not valid shell variable names.
1727     case $ac_envvar in #(
1728       '' | [0-9]* | *[!_$as_cr_alnum]* )
1729       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1730     esac
1731     eval $ac_envvar=\$ac_optarg
1732     export $ac_envvar ;;
1733 
1734   *)
1735     # FIXME: should be removed in autoconf 3.0.
1736     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1737     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1738       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1739     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1740     ;;
1741 
1742   esac
1743 done
1744 
1745 if test -n "$ac_prev"; then
1746   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1747   as_fn_error $? "missing argument to $ac_option"
1748 fi
1749 
1750 if test -n "$ac_unrecognized_opts"; then
1751   case $enable_option_checking in
1752     no) ;;
1753     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1754     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1755   esac
1756 fi
1757 
1758 # Check all directory arguments for consistency.
1759 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1760                 datadir sysconfdir sharedstatedir localstatedir includedir \
1761                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1762                 libdir localedir mandir
1763 do
1764   eval ac_val=\$$ac_var
1765   # Remove trailing slashes.
1766   case $ac_val in
1767     */ )
1768       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1769       eval $ac_var=\$ac_val;;
1770   esac
1771   # Be sure to have absolute directory names.
1772   case $ac_val in
1773     [\\/$]* | ?:[\\/]* )  continue;;
1774     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1775   esac
1776   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1777 done
1778 
1779 # There might be people who depend on the old broken behavior: `$host'
1780 # used to hold the argument of --host etc.
1781 # FIXME: To remove some day.
1782 build=$build_alias
1783 host=$host_alias
1784 target=$target_alias
1785 
1786 # FIXME: To remove some day.
1787 if test "x$host_alias" != x; then
1788   if test "x$build_alias" = x; then
1789     cross_compiling=maybe
1790   elif test "x$build_alias" != "x$host_alias"; then
1791     cross_compiling=yes
1792   fi
1793 fi
1794 
1795 ac_tool_prefix=
1796 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1797 
1798 test "$silent" = yes && exec 6>/dev/null
1799 
1800 
1801 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1802 ac_ls_di=`ls -di .` &&
1803 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1804   as_fn_error $? "working directory cannot be determined"
1805 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1806   as_fn_error $? "pwd does not report name of working directory"
1807 
1808 
1809 # Find the source files, if location was not specified.
1810 if test -z "$srcdir"; then
1811   ac_srcdir_defaulted=yes
1812   # Try the directory containing this script, then the parent directory.
1813   ac_confdir=`$as_dirname -- "$as_myself" ||
1814 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1815          X"$as_myself" : 'X\(//\)[^/]' \| \
1816          X"$as_myself" : 'X\(//\)$' \| \
1817          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1818 $as_echo X"$as_myself" |
1819     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1820             s//\1/
1821             q
1822           }
1823           /^X\(\/\/\)[^/].*/{
1824             s//\1/
1825             q
1826           }
1827           /^X\(\/\/\)$/{
1828             s//\1/
1829             q
1830           }
1831           /^X\(\/\).*/{
1832             s//\1/
1833             q
1834           }
1835           s/.*/./; q'`
1836   srcdir=$ac_confdir
1837   if test ! -r "$srcdir/$ac_unique_file"; then
1838     srcdir=..
1839   fi
1840 else
1841   ac_srcdir_defaulted=no
1842 fi
1843 if test ! -r "$srcdir/$ac_unique_file"; then
1844   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1845   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1846 fi
1847 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1848 ac_abs_confdir=`(
1849         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1850         pwd)`
1851 # When building in place, set srcdir=.
1852 if test "$ac_abs_confdir" = "$ac_pwd"; then
1853   srcdir=.
1854 fi
1855 # Remove unnecessary trailing slashes from srcdir.
1856 # Double slashes in file names in object file debugging info
1857 # mess up M-x gdb in Emacs.
1858 case $srcdir in
1859 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1860 esac
1861 for ac_var in $ac_precious_vars; do
1862   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1863   eval ac_env_${ac_var}_value=\$${ac_var}
1864   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1865   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1866 done
1867 
1868 #
1869 # Report the --help message.
1870 #
1871 if test "$ac_init_help" = "long"; then
1872   # Omit some internal or obsolete options to make the list less imposing.
1873   # This message is too long to be a string in the A/UX 3.1 sh.
1874   cat <<_ACEOF
1875 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1876 
1877 Usage: $0 [OPTION]... [VAR=VALUE]...
1878 
1879 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1880 VAR=VALUE.  See below for descriptions of some of the useful variables.
1881 
1882 Defaults for the options are specified in brackets.
1883 
1884 Configuration:
1885   -h, --help              display this help and exit
1886       --help=short        display options specific to this package
1887       --help=recursive    display the short help of all the included packages
1888   -V, --version           display version information and exit
1889   -q, --quiet, --silent   do not print \`checking ...' messages
1890       --cache-file=FILE   cache test results in FILE [disabled]
1891   -C, --config-cache      alias for \`--cache-file=config.cache'
1892   -n, --no-create         do not create output files
1893       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1894 
1895 Installation directories:
1896   --prefix=PREFIX         install architecture-independent files in PREFIX
1897                           [$ac_default_prefix]
1898   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1899                           [PREFIX]
1900 
1901 By default, \`make install' will install all the files in
1902 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1903 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1904 for instance \`--prefix=\$HOME'.
1905 
1906 For better control, use the options below.
1907 
1908 Fine tuning of the installation directories:
1909   --bindir=DIR            user executables [EPREFIX/bin]
1910   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1911   --libexecdir=DIR        program executables [EPREFIX/libexec]
1912   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1913   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1914   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1915   --libdir=DIR            object code libraries [EPREFIX/lib]
1916   --includedir=DIR        C header files [PREFIX/include]
1917   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1918   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1919   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1920   --infodir=DIR           info documentation [DATAROOTDIR/info]
1921   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1922   --mandir=DIR            man documentation [DATAROOTDIR/man]
1923   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1924   --htmldir=DIR           html documentation [DOCDIR]
1925   --dvidir=DIR            dvi documentation [DOCDIR]
1926   --pdfdir=DIR            pdf documentation [DOCDIR]
1927   --psdir=DIR             ps documentation [DOCDIR]
1928 _ACEOF
1929 
1930   cat <<\_ACEOF
1931 
1932 X features:
1933   --x-includes=DIR    X include files are in DIR
1934   --x-libraries=DIR   X library files are in DIR
1935 
1936 System types:
1937   --build=BUILD     configure for building on BUILD [guessed]
1938   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1939   --target=TARGET   configure for building compilers for TARGET [HOST]
1940 _ACEOF
1941 fi
1942 
1943 if test -n "$ac_init_help"; then
1944   case $ac_init_help in
1945      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1946    esac
1947   cat <<\_ACEOF
1948 
1949 Optional Features:
1950   --disable-option-checking  ignore unrecognized --enable/--with options
1951   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1952   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1953   --enable-openjdk-only   suppress building custom source even if present
1954                           [disabled]
1955   --enable-debug          set the debug level to fastdebug (shorthand for
1956                           --with-debug-level=fastdebug) [disabled]
1957   --disable-headful       disable building headful support (graphical UI
1958                           support) [enabled]
1959   --enable-unlimited-crypto
1960                           Enable unlimited crypto policy [disabled]
1961   --disable-keep-packaged-modules
1962                           Do not keep packaged modules in jdk image [enable]
1963   --enable-static-build   enable static library build [disabled]
1964   --disable-warnings-as-errors
1965                           do not consider native warnings to be an error
1966                           [enabled]
1967   --enable-debug-symbols  Deprecated. Option is kept for backwards
1968                           compatibility and is ignored
1969   --enable-zip-debug-info Deprecated. Option is kept for backwards
1970                           compatibility and is ignored
1971   --enable-native-coverage
1972                           enable native compilation with code coverage
1973                           data[disabled]
1974   --enable-dtrace[=yes/no/auto]
1975                           enable dtrace. Default is auto, where dtrace is
1976                           enabled if all dependencies are present.
1977   --disable-freetype-bundling
1978                           disable bundling of the freetype library with the
1979                           build result [enabled on Windows or when using
1980                           --with-freetype, disabled otherwise]
1981   --enable-sjavac         use sjavac to do fast incremental compiles
1982                           [disabled]
1983   --disable-javac-server  disable javac server [enabled]
1984   --enable-icecc          enable distribted compilation of native code using
1985                           icecc/icecream [disabled]
1986   --disable-precompiled-headers
1987                           disable using precompiled headers when compiling C++
1988                           [enabled]
1989   --enable-ccache         enable using ccache to speed up recompilations
1990                           [disabled]
1991 
1992 Optional Packages:
1993   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1994   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1995   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1996                           support it), e.g. --with-target-bits=32 [guessed]
1997   --with-custom-make-dir  Deprecated. Option is kept for backwards
1998                           compatibility and is ignored
1999   --with-jdk-variant      JDK variant to build (normal) [normal]
2000   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
2001                           optimized) [release]
2002   --with-jvm-variants     JVM variants (separated by commas) to build
2003                           (server,client,minimal,core,zero,zeroshark,custom)
2004                           [server]
2005   --with-devkit           use this devkit for compilers, tools and resources
2006   --with-sys-root         alias for --with-sysroot for backwards compatability
2007   --with-sysroot          use this directory as sysroot
2008   --with-tools-dir        alias for --with-toolchain-path for backwards
2009                           compatibility
2010   --with-toolchain-path   prepend these directories when searching for
2011                           toolchain binaries (compilers etc)
2012   --with-extra-path       prepend these directories to the default path
2013   --with-sdk-name         use the platform SDK of the given name. [macosx]
2014   --with-conf-name        use this as the name of the configuration [generated
2015                           from important configuration options]
2016   --with-output-sync      set make output sync type if supported by make.
2017                           [recurse]
2018   --with-default-make-target
2019                           set the default make target [exploded-image]
2020   --with-cacerts-file     specify alternative cacerts file
2021   --with-copyright-year   Set copyright year value for build [current year]
2022   --with-milestone        Deprecated. Option is kept for backwards
2023                           compatibility and is ignored
2024   --with-update-version   Deprecated. Option is kept for backwards
2025                           compatibility and is ignored
2026   --with-user-release-suffix
2027                           Deprecated. Option is kept for backwards
2028                           compatibility and is ignored
2029   --with-build-number     Deprecated. Option is kept for backwards
2030                           compatibility and is ignored
2031   --with-version-string   Set version string [calculated]
2032   --with-version-pre      Set the base part of the version 'PRE' field
2033                           (pre-release identifier) ['internal']
2034   --with-version-opt      Set version 'OPT' field (build metadata)
2035                           [<timestamp>.<user>.<dirname>]
2036   --with-version-build    Set version 'BUILD' field (build number) [not
2037                           specified]
2038   --with-version-major    Set version 'MAJOR' field (first number) [current
2039                           source value]
2040   --with-version-minor    Set version 'MINOR' field (second number) [current
2041                           source value]
2042   --with-version-security Set version 'SECURITY' field (third number) [current
2043                           source value]
2044   --with-version-patch    Set version 'PATCH' field (fourth number) [not
2045                           specified]
2046   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
2047   --with-build-jdk        path to JDK of same version as is being built[the
2048                           newly built JDK]
2049   --with-add-source-root  Deprecated. Option is kept for backwards
2050                           compatibility and is ignored
2051   --with-override-source-root
2052                           Deprecated. Option is kept for backwards
2053                           compatibility and is ignored
2054   --with-adds-and-overrides
2055                           Deprecated. Option is kept for backwards
2056                           compatibility and is ignored
2057   --with-override-langtools
2058                           Deprecated. Option is kept for backwards
2059                           compatibility and is ignored
2060   --with-override-corba   Deprecated. Option is kept for backwards
2061                           compatibility and is ignored
2062   --with-override-jaxp    Deprecated. Option is kept for backwards
2063                           compatibility and is ignored
2064   --with-override-jaxws   Deprecated. Option is kept for backwards
2065                           compatibility and is ignored
2066   --with-override-hotspot Deprecated. Option is kept for backwards
2067                           compatibility and is ignored
2068   --with-override-nashorn Deprecated. Option is kept for backwards
2069                           compatibility and is ignored
2070   --with-override-jdk     Deprecated. Option is kept for backwards
2071                           compatibility and is ignored
2072   --with-import-hotspot   import hotspot binaries from this jdk image or
2073                           hotspot build dist dir instead of building from
2074                           source
2075   --with-import-modules   import a set of prebuilt modules either as a zip
2076                           file or an exploded directory
2077   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
2078                           to show possible values [platform dependent]
2079   --with-extra-cflags     extra flags to be used when compiling jdk c-files
2080   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
2081   --with-extra-ldflags    extra flags to be used when linking jdk
2082   --with-toolchain-version
2083                           the version of the toolchain to look for, use
2084                           '--help' to show possible values [platform
2085                           dependent]
2086   --with-build-devkit     Devkit to use for the build platform toolchain
2087   --with-jtreg            Regression Test Harness [probed]
2088   --with-native-debug-symbols
2089                           set the native debug symbol configuration (none,
2090                           internal, external, zipped) [varying]
2091   --with-jvm-features     additional JVM features to enable (separated by
2092                           comma), use '--help' to show possible values [none]
2093   --with-jvm-interpreter  Deprecated. Option is kept for backwards
2094                           compatibility and is ignored
2095   --with-stdc++lib=<static>,<dynamic>,<default>
2096                           force linking of the C++ runtime on Linux to either
2097                           static or dynamic, default is static with dynamic as
2098                           fallback
2099   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
2100                           (Windows only) [probed]
2101   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
2102                           (Windows only) [probed]
2103   --with-x                use the X Window System
2104   --with-cups             specify prefix directory for the cups package
2105                           (expecting the headers under PATH/include)
2106   --with-cups-include     specify directory for the cups include files
2107   --with-freetype         specify prefix directory for the freetype package
2108                           (expecting the libraries under PATH/lib and the
2109                           headers under PATH/include)
2110   --with-freetype-include specify directory for the freetype include files
2111   --with-freetype-lib     specify directory for the freetype library
2112   --with-freetype-src     specify directory with freetype sources to
2113                           automatically build the library (experimental,
2114                           Windows-only)
2115   --with-alsa             specify prefix directory for the alsa package
2116                           (expecting the libraries under PATH/lib and the
2117                           headers under PATH/include)
2118   --with-alsa-include     specify directory for the alsa include files
2119   --with-alsa-lib         specify directory for the alsa library
2120   --with-libffi           specify prefix directory for the libffi package
2121                           (expecting the libraries under PATH/lib and the
2122                           headers under PATH/include)
2123   --with-libffi-include   specify directory for the libffi include files
2124   --with-libffi-lib       specify directory for the libffi library
2125   --with-libjpeg          use libjpeg from build system or OpenJDK source
2126                           (system, bundled) [bundled]
2127   --with-giflib           use giflib from build system or OpenJDK source
2128                           (system, bundled) [bundled]
2129   --with-libpng           use libpng from build system or OpenJDK source
2130                           (system, bundled) [bundled]
2131   --with-zlib             use zlib from build system or OpenJDK source
2132                           (system, bundled) [bundled]
2133   --with-lcms             use lcms2 from build system or OpenJDK source
2134                           (system, bundled) [bundled]
2135   --with-dxsdk            Deprecated. Option is kept for backwards
2136                           compatibility and is ignored
2137   --with-dxsdk-lib        Deprecated. Option is kept for backwards
2138                           compatibility and is ignored
2139   --with-dxsdk-include    Deprecated. Option is kept for backwards
2140                           compatibility and is ignored
2141   --with-num-cores        number of cores in the build system, e.g.
2142                           --with-num-cores=8 [probed]
2143   --with-memory-size      memory (in MB) available in the build system, e.g.
2144                           --with-memory-size=1024 [probed]
2145   --with-jobs             number of parallel jobs to let make run [calculated
2146                           based on cores and memory]
2147   --with-test-jobs        number of parallel tests jobs to run [based on build
2148                           jobs]
2149   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
2150                           invocations of boot JDK, overriding the default
2151                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
2152                           -enableassertions"
2153   --with-sjavac-server-java
2154                           use this java binary for running the sjavac
2155                           background server [Boot JDK java]
2156   --with-ccache-dir       where to store ccache files [~/.ccache]
2157 
2158 Some influential environment variables:
2159   BASENAME    Override default value for BASENAME
2160   BASH        Override default value for BASH
2161   CAT         Override default value for CAT
2162   CHMOD       Override default value for CHMOD
2163   CMP         Override default value for CMP
2164   COMM        Override default value for COMM
2165   CP          Override default value for CP
2166   CUT         Override default value for CUT
2167   DATE        Override default value for DATE
2168   DIFF        Override default value for DIFF
2169   DIRNAME     Override default value for DIRNAME
2170   ECHO        Override default value for ECHO
2171   EXPR        Override default value for EXPR
2172   FILE        Override default value for FILE
2173   FIND        Override default value for FIND
2174   HEAD        Override default value for HEAD
2175   LN          Override default value for LN
2176   LS          Override default value for LS
2177   MKDIR       Override default value for MKDIR
2178   MKTEMP      Override default value for MKTEMP
2179   MV          Override default value for MV
2180   NAWK        Override default value for NAWK
2181   PRINTF      Override default value for PRINTF
2182   RM          Override default value for RM
2183   RMDIR       Override default value for RMDIR
2184   SH          Override default value for SH
2185   SORT        Override default value for SORT
2186   TAIL        Override default value for TAIL
2187   TAR         Override default value for TAR
2188   TEE         Override default value for TEE
2189   TOUCH       Override default value for TOUCH
2190   TR          Override default value for TR
2191   UNAME       Override default value for UNAME
2192   UNIQ        Override default value for UNIQ
2193   WC          Override default value for WC
2194   WHICH       Override default value for WHICH
2195   XARGS       Override default value for XARGS
2196   AWK         Override default value for AWK
2197   GREP        Override default value for GREP
2198   EGREP       Override default value for EGREP
2199   FGREP       Override default value for FGREP
2200   SED         Override default value for SED
2201   CYGPATH     Override default value for CYGPATH
2202   READLINK    Override default value for READLINK
2203   DF          Override default value for DF
2204   CPIO        Override default value for CPIO
2205   NICE        Override default value for NICE
2206   MAKE        Override default value for MAKE
2207   UNZIP       Override default value for UNZIP
2208   ZIP         Override default value for ZIP
2209   LDD         Override default value for LDD
2210   OTOOL       Override default value for OTOOL
2211   READELF     Override default value for READELF
2212   HG          Override default value for HG
2213   STAT        Override default value for STAT
2214   TIME        Override default value for TIME
2215   DTRACE      Override default value for DTRACE
2216   PATCH       Override default value for PATCH
2217   DSYMUTIL    Override default value for DSYMUTIL
2218   XATTR       Override default value for XATTR
2219   CODESIGN    Override default value for CODESIGN
2220   SETFILE     Override default value for SETFILE
2221   PKG_CONFIG  path to pkg-config utility
2222   JAVA        Override default value for JAVA
2223   JAVAC       Override default value for JAVAC
2224   JAVAH       Override default value for JAVAH
2225   JAR         Override default value for JAR
2226   JARSIGNER   Override default value for JARSIGNER
2227   CC          C compiler command
2228   CFLAGS      C compiler flags
2229   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2230               nonstandard directory <lib dir>
2231   LIBS        libraries to pass to the linker, e.g. -l<library>
2232   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2233               you have headers in a nonstandard directory <include dir>
2234   CXX         C++ compiler command
2235   CXXFLAGS    C++ compiler flags
2236   CPP         C preprocessor
2237   CXXCPP      C++ preprocessor
2238   AS          Override default value for AS
2239   AR          Override default value for AR
2240   LIPO        Override default value for LIPO
2241   STRIP       Override default value for STRIP
2242   NM          Override default value for NM
2243   GNM         Override default value for GNM
2244   OBJCOPY     Override default value for OBJCOPY
2245   OBJDUMP     Override default value for OBJDUMP
2246   BUILD_CC    Override default value for BUILD_CC
2247   BUILD_CXX   Override default value for BUILD_CXX
2248   BUILD_NM    Override default value for BUILD_NM
2249   BUILD_AR    Override default value for BUILD_AR
2250   BUILD_OBJCOPY
2251               Override default value for BUILD_OBJCOPY
2252   BUILD_STRIP Override default value for BUILD_STRIP
2253   JTREGEXE    Override default value for JTREGEXE
2254   XMKMF       Path to xmkmf, Makefile generator for X Window System
2255   FREETYPE_CFLAGS
2256               C compiler flags for FREETYPE, overriding pkg-config
2257   FREETYPE_LIBS
2258               linker flags for FREETYPE, overriding pkg-config
2259   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2260   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2261   LIBFFI_CFLAGS
2262               C compiler flags for LIBFFI, overriding pkg-config
2263   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2264   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2265   PNG_LIBS    linker flags for PNG, overriding pkg-config
2266   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2267   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2268   ICECC_CMD   Override default value for ICECC_CMD
2269   ICECC_CREATE_ENV
2270               Override default value for ICECC_CREATE_ENV
2271   ICECC_WRAPPER
2272               Override default value for ICECC_WRAPPER
2273   CCACHE      Override default value for CCACHE
2274 
2275 Use these variables to override the choices made by `configure' or to help
2276 it to find libraries and programs with nonstandard names/locations.
2277 
2278 Report bugs to <build-dev@openjdk.java.net>.
2279 OpenJDK home page: <http://openjdk.java.net>.
2280 _ACEOF
2281 ac_status=$?
2282 fi
2283 
2284 if test "$ac_init_help" = "recursive"; then
2285   # If there are subdirs, report their specific --help.
2286   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2287     test -d "$ac_dir" ||
2288       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2289       continue
2290     ac_builddir=.
2291 
2292 case "$ac_dir" in
2293 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2294 *)
2295   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2296   # A ".." for each directory in $ac_dir_suffix.
2297   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2298   case $ac_top_builddir_sub in
2299   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2300   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2301   esac ;;
2302 esac
2303 ac_abs_top_builddir=$ac_pwd
2304 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2305 # for backward compatibility:
2306 ac_top_builddir=$ac_top_build_prefix
2307 
2308 case $srcdir in
2309   .)  # We are building in place.
2310     ac_srcdir=.
2311     ac_top_srcdir=$ac_top_builddir_sub
2312     ac_abs_top_srcdir=$ac_pwd ;;
2313   [\\/]* | ?:[\\/]* )  # Absolute name.
2314     ac_srcdir=$srcdir$ac_dir_suffix;
2315     ac_top_srcdir=$srcdir
2316     ac_abs_top_srcdir=$srcdir ;;
2317   *) # Relative name.
2318     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2319     ac_top_srcdir=$ac_top_build_prefix$srcdir
2320     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2321 esac
2322 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2323 
2324     cd "$ac_dir" || { ac_status=$?; continue; }
2325     # Check for guested configure.
2326     if test -f "$ac_srcdir/configure.gnu"; then
2327       echo &&
2328       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2329     elif test -f "$ac_srcdir/configure"; then
2330       echo &&
2331       $SHELL "$ac_srcdir/configure" --help=recursive
2332     else
2333       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2334     fi || ac_status=$?
2335     cd "$ac_pwd" || { ac_status=$?; break; }
2336   done
2337 fi
2338 
2339 test -n "$ac_init_help" && exit $ac_status
2340 if $ac_init_version; then
2341   cat <<\_ACEOF
2342 OpenJDK configure jdk9
2343 generated by GNU Autoconf 2.69
2344 
2345 Copyright (C) 2012 Free Software Foundation, Inc.
2346 This configure script is free software; the Free Software Foundation
2347 gives unlimited permission to copy, distribute and modify it.
2348 _ACEOF
2349   exit
2350 fi
2351 
2352 ## ------------------------ ##
2353 ## Autoconf initialization. ##
2354 ## ------------------------ ##
2355 
2356 # ac_fn_c_try_compile LINENO
2357 # --------------------------
2358 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2359 ac_fn_c_try_compile ()
2360 {
2361   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2362   rm -f conftest.$ac_objext
2363   if { { ac_try="$ac_compile"
2364 case "(($ac_try" in
2365   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2366   *) ac_try_echo=$ac_try;;
2367 esac
2368 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2369 $as_echo "$ac_try_echo"; } >&5
2370   (eval "$ac_compile") 2>conftest.err
2371   ac_status=$?
2372   if test -s conftest.err; then
2373     grep -v '^ *+' conftest.err >conftest.er1
2374     cat conftest.er1 >&5
2375     mv -f conftest.er1 conftest.err
2376   fi
2377   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2378   test $ac_status = 0; } && {
2379          test -z "$ac_c_werror_flag" ||
2380          test ! -s conftest.err
2381        } && test -s conftest.$ac_objext; then :
2382   ac_retval=0
2383 else
2384   $as_echo "$as_me: failed program was:" >&5
2385 sed 's/^/| /' conftest.$ac_ext >&5
2386 
2387         ac_retval=1
2388 fi
2389   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2390   as_fn_set_status $ac_retval
2391 
2392 } # ac_fn_c_try_compile
2393 
2394 # ac_fn_cxx_try_compile LINENO
2395 # ----------------------------
2396 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2397 ac_fn_cxx_try_compile ()
2398 {
2399   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2400   rm -f conftest.$ac_objext
2401   if { { ac_try="$ac_compile"
2402 case "(($ac_try" in
2403   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2404   *) ac_try_echo=$ac_try;;
2405 esac
2406 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2407 $as_echo "$ac_try_echo"; } >&5
2408   (eval "$ac_compile") 2>conftest.err
2409   ac_status=$?
2410   if test -s conftest.err; then
2411     grep -v '^ *+' conftest.err >conftest.er1
2412     cat conftest.er1 >&5
2413     mv -f conftest.er1 conftest.err
2414   fi
2415   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2416   test $ac_status = 0; } && {
2417          test -z "$ac_cxx_werror_flag" ||
2418          test ! -s conftest.err
2419        } && test -s conftest.$ac_objext; then :
2420   ac_retval=0
2421 else
2422   $as_echo "$as_me: failed program was:" >&5
2423 sed 's/^/| /' conftest.$ac_ext >&5
2424 
2425         ac_retval=1
2426 fi
2427   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2428   as_fn_set_status $ac_retval
2429 
2430 } # ac_fn_cxx_try_compile
2431 
2432 # ac_fn_c_try_cpp LINENO
2433 # ----------------------
2434 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2435 ac_fn_c_try_cpp ()
2436 {
2437   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2438   if { { ac_try="$ac_cpp conftest.$ac_ext"
2439 case "(($ac_try" in
2440   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2441   *) ac_try_echo=$ac_try;;
2442 esac
2443 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2444 $as_echo "$ac_try_echo"; } >&5
2445   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2446   ac_status=$?
2447   if test -s conftest.err; then
2448     grep -v '^ *+' conftest.err >conftest.er1
2449     cat conftest.er1 >&5
2450     mv -f conftest.er1 conftest.err
2451   fi
2452   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2453   test $ac_status = 0; } > conftest.i && {
2454          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2455          test ! -s conftest.err
2456        }; then :
2457   ac_retval=0
2458 else
2459   $as_echo "$as_me: failed program was:" >&5
2460 sed 's/^/| /' conftest.$ac_ext >&5
2461 
2462     ac_retval=1
2463 fi
2464   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2465   as_fn_set_status $ac_retval
2466 
2467 } # ac_fn_c_try_cpp
2468 
2469 # ac_fn_cxx_try_cpp LINENO
2470 # ------------------------
2471 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2472 ac_fn_cxx_try_cpp ()
2473 {
2474   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2475   if { { ac_try="$ac_cpp conftest.$ac_ext"
2476 case "(($ac_try" in
2477   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2478   *) ac_try_echo=$ac_try;;
2479 esac
2480 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2481 $as_echo "$ac_try_echo"; } >&5
2482   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2483   ac_status=$?
2484   if test -s conftest.err; then
2485     grep -v '^ *+' conftest.err >conftest.er1
2486     cat conftest.er1 >&5
2487     mv -f conftest.er1 conftest.err
2488   fi
2489   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2490   test $ac_status = 0; } > conftest.i && {
2491          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2492          test ! -s conftest.err
2493        }; then :
2494   ac_retval=0
2495 else
2496   $as_echo "$as_me: failed program was:" >&5
2497 sed 's/^/| /' conftest.$ac_ext >&5
2498 
2499     ac_retval=1
2500 fi
2501   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2502   as_fn_set_status $ac_retval
2503 
2504 } # ac_fn_cxx_try_cpp
2505 
2506 # ac_fn_c_try_link LINENO
2507 # -----------------------
2508 # Try to link conftest.$ac_ext, and return whether this succeeded.
2509 ac_fn_c_try_link ()
2510 {
2511   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2512   rm -f conftest.$ac_objext conftest$ac_exeext
2513   if { { ac_try="$ac_link"
2514 case "(($ac_try" in
2515   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2516   *) ac_try_echo=$ac_try;;
2517 esac
2518 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2519 $as_echo "$ac_try_echo"; } >&5
2520   (eval "$ac_link") 2>conftest.err
2521   ac_status=$?
2522   if test -s conftest.err; then
2523     grep -v '^ *+' conftest.err >conftest.er1
2524     cat conftest.er1 >&5
2525     mv -f conftest.er1 conftest.err
2526   fi
2527   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2528   test $ac_status = 0; } && {
2529          test -z "$ac_c_werror_flag" ||
2530          test ! -s conftest.err
2531        } && test -s conftest$ac_exeext && {
2532          test "$cross_compiling" = yes ||
2533          test -x conftest$ac_exeext
2534        }; then :
2535   ac_retval=0
2536 else
2537   $as_echo "$as_me: failed program was:" >&5
2538 sed 's/^/| /' conftest.$ac_ext >&5
2539 
2540         ac_retval=1
2541 fi
2542   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2543   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2544   # interfere with the next link command; also delete a directory that is
2545   # left behind by Apple's compiler.  We do this before executing the actions.
2546   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2547   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2548   as_fn_set_status $ac_retval
2549 
2550 } # ac_fn_c_try_link
2551 
2552 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2553 # ---------------------------------------------------------
2554 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2555 # the include files in INCLUDES and setting the cache variable VAR
2556 # accordingly.
2557 ac_fn_cxx_check_header_mongrel ()
2558 {
2559   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2560   if eval \${$3+:} false; then :
2561   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2562 $as_echo_n "checking for $2... " >&6; }
2563 if eval \${$3+:} false; then :
2564   $as_echo_n "(cached) " >&6
2565 fi
2566 eval ac_res=\$$3
2567                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2568 $as_echo "$ac_res" >&6; }
2569 else
2570   # Is the header compilable?
2571 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2572 $as_echo_n "checking $2 usability... " >&6; }
2573 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2574 /* end confdefs.h.  */
2575 $4
2576 #include <$2>
2577 _ACEOF
2578 if ac_fn_cxx_try_compile "$LINENO"; then :
2579   ac_header_compiler=yes
2580 else
2581   ac_header_compiler=no
2582 fi
2583 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2584 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2585 $as_echo "$ac_header_compiler" >&6; }
2586 
2587 # Is the header present?
2588 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2589 $as_echo_n "checking $2 presence... " >&6; }
2590 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2591 /* end confdefs.h.  */
2592 #include <$2>
2593 _ACEOF
2594 if ac_fn_cxx_try_cpp "$LINENO"; then :
2595   ac_header_preproc=yes
2596 else
2597   ac_header_preproc=no
2598 fi
2599 rm -f conftest.err conftest.i conftest.$ac_ext
2600 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2601 $as_echo "$ac_header_preproc" >&6; }
2602 
2603 # So?  What about this header?
2604 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2605   yes:no: )
2606     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2607 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2608     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2609 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2610     ;;
2611   no:yes:* )
2612     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2613 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2614     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2615 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2616     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2617 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2618     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2619 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2620     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2621 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2622 ( $as_echo "## ----------------------------------------- ##
2623 ## Report this to build-dev@openjdk.java.net ##
2624 ## ----------------------------------------- ##"
2625      ) | sed "s/^/$as_me: WARNING:     /" >&2
2626     ;;
2627 esac
2628   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2629 $as_echo_n "checking for $2... " >&6; }
2630 if eval \${$3+:} false; then :
2631   $as_echo_n "(cached) " >&6
2632 else
2633   eval "$3=\$ac_header_compiler"
2634 fi
2635 eval ac_res=\$$3
2636                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2637 $as_echo "$ac_res" >&6; }
2638 fi
2639   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2640 
2641 } # ac_fn_cxx_check_header_mongrel
2642 
2643 # ac_fn_cxx_try_run LINENO
2644 # ------------------------
2645 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2646 # that executables *can* be run.
2647 ac_fn_cxx_try_run ()
2648 {
2649   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2650   if { { ac_try="$ac_link"
2651 case "(($ac_try" in
2652   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2653   *) ac_try_echo=$ac_try;;
2654 esac
2655 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2656 $as_echo "$ac_try_echo"; } >&5
2657   (eval "$ac_link") 2>&5
2658   ac_status=$?
2659   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2660   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2661   { { case "(($ac_try" in
2662   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2663   *) ac_try_echo=$ac_try;;
2664 esac
2665 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2666 $as_echo "$ac_try_echo"; } >&5
2667   (eval "$ac_try") 2>&5
2668   ac_status=$?
2669   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2670   test $ac_status = 0; }; }; then :
2671   ac_retval=0
2672 else
2673   $as_echo "$as_me: program exited with status $ac_status" >&5
2674        $as_echo "$as_me: failed program was:" >&5
2675 sed 's/^/| /' conftest.$ac_ext >&5
2676 
2677        ac_retval=$ac_status
2678 fi
2679   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2680   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2681   as_fn_set_status $ac_retval
2682 
2683 } # ac_fn_cxx_try_run
2684 
2685 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2686 # ---------------------------------------------------------
2687 # Tests whether HEADER exists and can be compiled using the include files in
2688 # INCLUDES, setting the cache variable VAR accordingly.
2689 ac_fn_cxx_check_header_compile ()
2690 {
2691   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2692   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2693 $as_echo_n "checking for $2... " >&6; }
2694 if eval \${$3+:} false; then :
2695   $as_echo_n "(cached) " >&6
2696 else
2697   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2698 /* end confdefs.h.  */
2699 $4
2700 #include <$2>
2701 _ACEOF
2702 if ac_fn_cxx_try_compile "$LINENO"; then :
2703   eval "$3=yes"
2704 else
2705   eval "$3=no"
2706 fi
2707 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2708 fi
2709 eval ac_res=\$$3
2710                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2711 $as_echo "$ac_res" >&6; }
2712   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2713 
2714 } # ac_fn_cxx_check_header_compile
2715 
2716 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2717 # ----------------------------------------------
2718 # Tries to find the compile-time value of EXPR in a program that includes
2719 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2720 # computed
2721 ac_fn_cxx_compute_int ()
2722 {
2723   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2724   if test "$cross_compiling" = yes; then
2725     # Depending upon the size, compute the lo and hi bounds.
2726 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2727 /* end confdefs.h.  */
2728 $4
2729 int
2730 main ()
2731 {
2732 static int test_array [1 - 2 * !(($2) >= 0)];
2733 test_array [0] = 0;
2734 return test_array [0];
2735 
2736   ;
2737   return 0;
2738 }
2739 _ACEOF
2740 if ac_fn_cxx_try_compile "$LINENO"; then :
2741   ac_lo=0 ac_mid=0
2742   while :; do
2743     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2744 /* end confdefs.h.  */
2745 $4
2746 int
2747 main ()
2748 {
2749 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2750 test_array [0] = 0;
2751 return test_array [0];
2752 
2753   ;
2754   return 0;
2755 }
2756 _ACEOF
2757 if ac_fn_cxx_try_compile "$LINENO"; then :
2758   ac_hi=$ac_mid; break
2759 else
2760   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2761                         if test $ac_lo -le $ac_mid; then
2762                           ac_lo= ac_hi=
2763                           break
2764                         fi
2765                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2766 fi
2767 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2768   done
2769 else
2770   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2771 /* end confdefs.h.  */
2772 $4
2773 int
2774 main ()
2775 {
2776 static int test_array [1 - 2 * !(($2) < 0)];
2777 test_array [0] = 0;
2778 return test_array [0];
2779 
2780   ;
2781   return 0;
2782 }
2783 _ACEOF
2784 if ac_fn_cxx_try_compile "$LINENO"; then :
2785   ac_hi=-1 ac_mid=-1
2786   while :; do
2787     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2788 /* end confdefs.h.  */
2789 $4
2790 int
2791 main ()
2792 {
2793 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2794 test_array [0] = 0;
2795 return test_array [0];
2796 
2797   ;
2798   return 0;
2799 }
2800 _ACEOF
2801 if ac_fn_cxx_try_compile "$LINENO"; then :
2802   ac_lo=$ac_mid; break
2803 else
2804   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2805                         if test $ac_mid -le $ac_hi; then
2806                           ac_lo= ac_hi=
2807                           break
2808                         fi
2809                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2810 fi
2811 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2812   done
2813 else
2814   ac_lo= ac_hi=
2815 fi
2816 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2817 fi
2818 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2819 # Binary search between lo and hi bounds.
2820 while test "x$ac_lo" != "x$ac_hi"; do
2821   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2822   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2823 /* end confdefs.h.  */
2824 $4
2825 int
2826 main ()
2827 {
2828 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2829 test_array [0] = 0;
2830 return test_array [0];
2831 
2832   ;
2833   return 0;
2834 }
2835 _ACEOF
2836 if ac_fn_cxx_try_compile "$LINENO"; then :
2837   ac_hi=$ac_mid
2838 else
2839   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2840 fi
2841 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2842 done
2843 case $ac_lo in #((
2844 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2845 '') ac_retval=1 ;;
2846 esac
2847   else
2848     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2849 /* end confdefs.h.  */
2850 $4
2851 static long int longval () { return $2; }
2852 static unsigned long int ulongval () { return $2; }
2853 #include <stdio.h>
2854 #include <stdlib.h>
2855 int
2856 main ()
2857 {
2858 
2859   FILE *f = fopen ("conftest.val", "w");
2860   if (! f)
2861     return 1;
2862   if (($2) < 0)
2863     {
2864       long int i = longval ();
2865       if (i != ($2))
2866         return 1;
2867       fprintf (f, "%ld", i);
2868     }
2869   else
2870     {
2871       unsigned long int i = ulongval ();
2872       if (i != ($2))
2873         return 1;
2874       fprintf (f, "%lu", i);
2875     }
2876   /* Do not output a trailing newline, as this causes \r\n confusion
2877      on some platforms.  */
2878   return ferror (f) || fclose (f) != 0;
2879 
2880   ;
2881   return 0;
2882 }
2883 _ACEOF
2884 if ac_fn_cxx_try_run "$LINENO"; then :
2885   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2886 else
2887   ac_retval=1
2888 fi
2889 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2890   conftest.$ac_objext conftest.beam conftest.$ac_ext
2891 rm -f conftest.val
2892 
2893   fi
2894   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2895   as_fn_set_status $ac_retval
2896 
2897 } # ac_fn_cxx_compute_int
2898 
2899 # ac_fn_cxx_try_link LINENO
2900 # -------------------------
2901 # Try to link conftest.$ac_ext, and return whether this succeeded.
2902 ac_fn_cxx_try_link ()
2903 {
2904   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2905   rm -f conftest.$ac_objext conftest$ac_exeext
2906   if { { ac_try="$ac_link"
2907 case "(($ac_try" in
2908   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2909   *) ac_try_echo=$ac_try;;
2910 esac
2911 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2912 $as_echo "$ac_try_echo"; } >&5
2913   (eval "$ac_link") 2>conftest.err
2914   ac_status=$?
2915   if test -s conftest.err; then
2916     grep -v '^ *+' conftest.err >conftest.er1
2917     cat conftest.er1 >&5
2918     mv -f conftest.er1 conftest.err
2919   fi
2920   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2921   test $ac_status = 0; } && {
2922          test -z "$ac_cxx_werror_flag" ||
2923          test ! -s conftest.err
2924        } && test -s conftest$ac_exeext && {
2925          test "$cross_compiling" = yes ||
2926          test -x conftest$ac_exeext
2927        }; then :
2928   ac_retval=0
2929 else
2930   $as_echo "$as_me: failed program was:" >&5
2931 sed 's/^/| /' conftest.$ac_ext >&5
2932 
2933         ac_retval=1
2934 fi
2935   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2936   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2937   # interfere with the next link command; also delete a directory that is
2938   # left behind by Apple's compiler.  We do this before executing the actions.
2939   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2940   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2941   as_fn_set_status $ac_retval
2942 
2943 } # ac_fn_cxx_try_link
2944 
2945 # ac_fn_cxx_check_func LINENO FUNC VAR
2946 # ------------------------------------
2947 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2948 ac_fn_cxx_check_func ()
2949 {
2950   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2951   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2952 $as_echo_n "checking for $2... " >&6; }
2953 if eval \${$3+:} false; then :
2954   $as_echo_n "(cached) " >&6
2955 else
2956   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2957 /* end confdefs.h.  */
2958 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2959    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2960 #define $2 innocuous_$2
2961 
2962 /* System header to define __stub macros and hopefully few prototypes,
2963     which can conflict with char $2 (); below.
2964     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2965     <limits.h> exists even on freestanding compilers.  */
2966 
2967 #ifdef __STDC__
2968 # include <limits.h>
2969 #else
2970 # include <assert.h>
2971 #endif
2972 
2973 #undef $2
2974 
2975 /* Override any GCC internal prototype to avoid an error.
2976    Use char because int might match the return type of a GCC
2977    builtin and then its argument prototype would still apply.  */
2978 #ifdef __cplusplus
2979 extern "C"
2980 #endif
2981 char $2 ();
2982 /* The GNU C library defines this for functions which it implements
2983     to always fail with ENOSYS.  Some functions are actually named
2984     something starting with __ and the normal name is an alias.  */
2985 #if defined __stub_$2 || defined __stub___$2
2986 choke me
2987 #endif
2988 
2989 int
2990 main ()
2991 {
2992 return $2 ();
2993   ;
2994   return 0;
2995 }
2996 _ACEOF
2997 if ac_fn_cxx_try_link "$LINENO"; then :
2998   eval "$3=yes"
2999 else
3000   eval "$3=no"
3001 fi
3002 rm -f core conftest.err conftest.$ac_objext \
3003     conftest$ac_exeext conftest.$ac_ext
3004 fi
3005 eval ac_res=\$$3
3006                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3007 $as_echo "$ac_res" >&6; }
3008   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3009 
3010 } # ac_fn_cxx_check_func
3011 
3012 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
3013 # -------------------------------------------------------
3014 # Tests whether HEADER exists and can be compiled using the include files in
3015 # INCLUDES, setting the cache variable VAR accordingly.
3016 ac_fn_c_check_header_compile ()
3017 {
3018   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
3019   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
3020 $as_echo_n "checking for $2... " >&6; }
3021 if eval \${$3+:} false; then :
3022   $as_echo_n "(cached) " >&6
3023 else
3024   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3025 /* end confdefs.h.  */
3026 $4
3027 #include <$2>
3028 _ACEOF
3029 if ac_fn_c_try_compile "$LINENO"; then :
3030   eval "$3=yes"
3031 else
3032   eval "$3=no"
3033 fi
3034 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3035 fi
3036 eval ac_res=\$$3
3037                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
3038 $as_echo "$ac_res" >&6; }
3039   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
3040 
3041 } # ac_fn_c_check_header_compile
3042 cat >config.log <<_ACEOF
3043 This file contains any messages produced by compilers while
3044 running configure, to aid debugging if configure makes a mistake.
3045 
3046 It was created by OpenJDK $as_me jdk9, which was
3047 generated by GNU Autoconf 2.69.  Invocation command line was
3048 
3049   $ $0 $@
3050 
3051 _ACEOF
3052 exec 5>>config.log
3053 {
3054 cat <<_ASUNAME
3055 ## --------- ##
3056 ## Platform. ##
3057 ## --------- ##
3058 
3059 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
3060 uname -m = `(uname -m) 2>/dev/null || echo unknown`
3061 uname -r = `(uname -r) 2>/dev/null || echo unknown`
3062 uname -s = `(uname -s) 2>/dev/null || echo unknown`
3063 uname -v = `(uname -v) 2>/dev/null || echo unknown`
3064 
3065 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
3066 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
3067 
3068 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
3069 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
3070 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
3071 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
3072 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
3073 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
3074 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
3075 
3076 _ASUNAME
3077 
3078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3079 for as_dir in $PATH
3080 do
3081   IFS=$as_save_IFS
3082   test -z "$as_dir" && as_dir=.
3083     $as_echo "PATH: $as_dir"
3084   done
3085 IFS=$as_save_IFS
3086 
3087 } >&5
3088 
3089 cat >&5 <<_ACEOF
3090 
3091 
3092 ## ----------- ##
3093 ## Core tests. ##
3094 ## ----------- ##
3095 
3096 _ACEOF
3097 
3098 
3099 # Keep a trace of the command line.
3100 # Strip out --no-create and --no-recursion so they do not pile up.
3101 # Strip out --silent because we don't want to record it for future runs.
3102 # Also quote any args containing shell meta-characters.
3103 # Make two passes to allow for proper duplicate-argument suppression.
3104 ac_configure_args=
3105 ac_configure_args0=
3106 ac_configure_args1=
3107 ac_must_keep_next=false
3108 for ac_pass in 1 2
3109 do
3110   for ac_arg
3111   do
3112     case $ac_arg in
3113     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
3114     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
3115     | -silent | --silent | --silen | --sile | --sil)
3116       continue ;;
3117     *\'*)
3118       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
3119     esac
3120     case $ac_pass in
3121     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
3122     2)
3123       as_fn_append ac_configure_args1 " '$ac_arg'"
3124       if test $ac_must_keep_next = true; then
3125         ac_must_keep_next=false # Got value, back to normal.
3126       else
3127         case $ac_arg in
3128           *=* | --config-cache | -C | -disable-* | --disable-* \
3129           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
3130           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
3131           | -with-* | --with-* | -without-* | --without-* | --x)
3132             case "$ac_configure_args0 " in
3133               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
3134             esac
3135             ;;
3136           -* ) ac_must_keep_next=true ;;
3137         esac
3138       fi
3139       as_fn_append ac_configure_args " '$ac_arg'"
3140       ;;
3141     esac
3142   done
3143 done
3144 { ac_configure_args0=; unset ac_configure_args0;}
3145 { ac_configure_args1=; unset ac_configure_args1;}
3146 
3147 # When interrupted or exit'd, cleanup temporary files, and complete
3148 # config.log.  We remove comments because anyway the quotes in there
3149 # would cause problems or look ugly.
3150 # WARNING: Use '\'' to represent an apostrophe within the trap.
3151 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
3152 trap 'exit_status=$?
3153   # Save into config.log some information that might help in debugging.
3154   {
3155     echo
3156 
3157     $as_echo "## ---------------- ##
3158 ## Cache variables. ##
3159 ## ---------------- ##"
3160     echo
3161     # The following way of writing the cache mishandles newlines in values,
3162 (
3163   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
3164     eval ac_val=\$$ac_var
3165     case $ac_val in #(
3166     *${as_nl}*)
3167       case $ac_var in #(
3168       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3169 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3170       esac
3171       case $ac_var in #(
3172       _ | IFS | as_nl) ;; #(
3173       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3174       *) { eval $ac_var=; unset $ac_var;} ;;
3175       esac ;;
3176     esac
3177   done
3178   (set) 2>&1 |
3179     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3180     *${as_nl}ac_space=\ *)
3181       sed -n \
3182         "s/'\''/'\''\\\\'\'''\''/g;
3183           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3184       ;; #(
3185     *)
3186       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3187       ;;
3188     esac |
3189     sort
3190 )
3191     echo
3192 
3193     $as_echo "## ----------------- ##
3194 ## Output variables. ##
3195 ## ----------------- ##"
3196     echo
3197     for ac_var in $ac_subst_vars
3198     do
3199       eval ac_val=\$$ac_var
3200       case $ac_val in
3201       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3202       esac
3203       $as_echo "$ac_var='\''$ac_val'\''"
3204     done | sort
3205     echo
3206 
3207     if test -n "$ac_subst_files"; then
3208       $as_echo "## ------------------- ##
3209 ## File substitutions. ##
3210 ## ------------------- ##"
3211       echo
3212       for ac_var in $ac_subst_files
3213       do
3214         eval ac_val=\$$ac_var
3215         case $ac_val in
3216         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3217         esac
3218         $as_echo "$ac_var='\''$ac_val'\''"
3219       done | sort
3220       echo
3221     fi
3222 
3223     if test -s confdefs.h; then
3224       $as_echo "## ----------- ##
3225 ## confdefs.h. ##
3226 ## ----------- ##"
3227       echo
3228       cat confdefs.h
3229       echo
3230     fi
3231     test "$ac_signal" != 0 &&
3232       $as_echo "$as_me: caught signal $ac_signal"
3233     $as_echo "$as_me: exit $exit_status"
3234   } >&5
3235   rm -f core *.core core.conftest.* &&
3236     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3237     exit $exit_status
3238 ' 0
3239 for ac_signal in 1 2 13 15; do
3240   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3241 done
3242 ac_signal=0
3243 
3244 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3245 rm -f -r conftest* confdefs.h
3246 
3247 $as_echo "/* confdefs.h */" > confdefs.h
3248 
3249 # Predefined preprocessor variables.
3250 
3251 cat >>confdefs.h <<_ACEOF
3252 #define PACKAGE_NAME "$PACKAGE_NAME"
3253 _ACEOF
3254 
3255 cat >>confdefs.h <<_ACEOF
3256 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3257 _ACEOF
3258 
3259 cat >>confdefs.h <<_ACEOF
3260 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3261 _ACEOF
3262 
3263 cat >>confdefs.h <<_ACEOF
3264 #define PACKAGE_STRING "$PACKAGE_STRING"
3265 _ACEOF
3266 
3267 cat >>confdefs.h <<_ACEOF
3268 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3269 _ACEOF
3270 
3271 cat >>confdefs.h <<_ACEOF
3272 #define PACKAGE_URL "$PACKAGE_URL"
3273 _ACEOF
3274 
3275 
3276 # Let the site file select an alternate cache file if it wants to.
3277 # Prefer an explicitly selected file to automatically selected ones.
3278 ac_site_file1=NONE
3279 ac_site_file2=NONE
3280 if test -n "$CONFIG_SITE"; then
3281   # We do not want a PATH search for config.site.
3282   case $CONFIG_SITE in #((
3283     -*)  ac_site_file1=./$CONFIG_SITE;;
3284     */*) ac_site_file1=$CONFIG_SITE;;
3285     *)   ac_site_file1=./$CONFIG_SITE;;
3286   esac
3287 elif test "x$prefix" != xNONE; then
3288   ac_site_file1=$prefix/share/config.site
3289   ac_site_file2=$prefix/etc/config.site
3290 else
3291   ac_site_file1=$ac_default_prefix/share/config.site
3292   ac_site_file2=$ac_default_prefix/etc/config.site
3293 fi
3294 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3295 do
3296   test "x$ac_site_file" = xNONE && continue
3297   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3298     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3299 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3300     sed 's/^/| /' "$ac_site_file" >&5
3301     . "$ac_site_file" \
3302       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3303 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3304 as_fn_error $? "failed to load site script $ac_site_file
3305 See \`config.log' for more details" "$LINENO" 5; }
3306   fi
3307 done
3308 
3309 if test -r "$cache_file"; then
3310   # Some versions of bash will fail to source /dev/null (special files
3311   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3312   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3313     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3314 $as_echo "$as_me: loading cache $cache_file" >&6;}
3315     case $cache_file in
3316       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3317       *)                      . "./$cache_file";;
3318     esac
3319   fi
3320 else
3321   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3322 $as_echo "$as_me: creating cache $cache_file" >&6;}
3323   >$cache_file
3324 fi
3325 
3326 # Check that the precious variables saved in the cache have kept the same
3327 # value.
3328 ac_cache_corrupted=false
3329 for ac_var in $ac_precious_vars; do
3330   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3331   eval ac_new_set=\$ac_env_${ac_var}_set
3332   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3333   eval ac_new_val=\$ac_env_${ac_var}_value
3334   case $ac_old_set,$ac_new_set in
3335     set,)
3336       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3337 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3338       ac_cache_corrupted=: ;;
3339     ,set)
3340       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3341 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3342       ac_cache_corrupted=: ;;
3343     ,);;
3344     *)
3345       if test "x$ac_old_val" != "x$ac_new_val"; then
3346         # differences in whitespace do not lead to failure.
3347         ac_old_val_w=`echo x $ac_old_val`
3348         ac_new_val_w=`echo x $ac_new_val`
3349         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3350           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3351 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3352           ac_cache_corrupted=:
3353         else
3354           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3355 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3356           eval $ac_var=\$ac_old_val
3357         fi
3358         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3359 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3360         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3361 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3362       fi;;
3363   esac
3364   # Pass precious variables to config.status.
3365   if test "$ac_new_set" = set; then
3366     case $ac_new_val in
3367     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3368     *) ac_arg=$ac_var=$ac_new_val ;;
3369     esac
3370     case " $ac_configure_args " in
3371       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3372       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3373     esac
3374   fi
3375 done
3376 if $ac_cache_corrupted; then
3377   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3378 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3379   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3380 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3381   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3382 fi
3383 ## -------------------- ##
3384 ## Main body of script. ##
3385 ## -------------------- ##
3386 
3387 ac_ext=c
3388 ac_cpp='$CPP $CPPFLAGS'
3389 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3390 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3391 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3392 
3393 
3394 
3395 ac_aux_dir=
3396 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3397   if test -f "$ac_dir/install-sh"; then
3398     ac_aux_dir=$ac_dir
3399     ac_install_sh="$ac_aux_dir/install-sh -c"
3400     break
3401   elif test -f "$ac_dir/install.sh"; then
3402     ac_aux_dir=$ac_dir
3403     ac_install_sh="$ac_aux_dir/install.sh -c"
3404     break
3405   elif test -f "$ac_dir/shtool"; then
3406     ac_aux_dir=$ac_dir
3407     ac_install_sh="$ac_aux_dir/shtool install -c"
3408     break
3409   fi
3410 done
3411 if test -z "$ac_aux_dir"; then
3412   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
3413 fi
3414 
3415 # These three variables are undocumented and unsupported,
3416 # and are intended to be withdrawn in a future Autoconf release.
3417 # They can cause serious problems if a builder's source tree is in a directory
3418 # whose full name contains unusual characters.
3419 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3420 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3421 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3422 
3423 
3424 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3425 
3426 #
3427 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3428 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3429 #
3430 # This code is free software; you can redistribute it and/or modify it
3431 # under the terms of the GNU General Public License version 2 only, as
3432 # published by the Free Software Foundation.  Oracle designates this
3433 # particular file as subject to the "Classpath" exception as provided
3434 # by Oracle in the LICENSE file that accompanied this code.
3435 #
3436 # This code is distributed in the hope that it will be useful, but WITHOUT
3437 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3438 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3439 # version 2 for more details (a copy is included in the LICENSE file that
3440 # accompanied this code).
3441 #
3442 # You should have received a copy of the GNU General Public License version
3443 # 2 along with this work; if not, write to the Free Software Foundation,
3444 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3445 #
3446 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3447 # or visit www.oracle.com if you need additional information or have any
3448 # questions.
3449 #
3450 
3451 #
3452 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3453 #
3454 # This program is free software; you can redistribute it and/or modify
3455 # it under the terms of the GNU General Public License as published by
3456 # the Free Software Foundation; either version 2 of the License, or
3457 # (at your option) any later version.
3458 #
3459 # This program is distributed in the hope that it will be useful, but
3460 # WITHOUT ANY WARRANTY; without even the implied warranty of
3461 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3462 # General Public License for more details.
3463 #
3464 # You should have received a copy of the GNU General Public License
3465 # along with this program; if not, write to the Free Software
3466 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3467 #
3468 # As a special exception to the GNU General Public License, if you
3469 # distribute this file as part of a program that contains a
3470 # configuration script generated by Autoconf, you may include it under
3471 # the same distribution terms that you use for the rest of that program.
3472 
3473 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3474 # ----------------------------------
3475 # PKG_PROG_PKG_CONFIG
3476 
3477 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3478 #
3479 # Check to see whether a particular set of modules exists.  Similar
3480 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3481 #
3482 #
3483 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3484 # this or PKG_CHECK_MODULES is called, or make sure to call
3485 # PKG_CHECK_EXISTS manually
3486 # --------------------------------------------------------------
3487 
3488 
3489 
3490 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3491 # ---------------------------------------------
3492 # _PKG_CONFIG
3493 
3494 # _PKG_SHORT_ERRORS_SUPPORTED
3495 # -----------------------------
3496 # _PKG_SHORT_ERRORS_SUPPORTED
3497 
3498 
3499 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3500 # [ACTION-IF-NOT-FOUND])
3501 #
3502 #
3503 # Note that if there is a possibility the first call to
3504 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3505 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3506 #
3507 #
3508 # --------------------------------------------------------------
3509 # PKG_CHECK_MODULES
3510 
3511 
3512 # Include these first...
3513 #
3514 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3515 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3516 #
3517 # This code is free software; you can redistribute it and/or modify it
3518 # under the terms of the GNU General Public License version 2 only, as
3519 # published by the Free Software Foundation.  Oracle designates this
3520 # particular file as subject to the "Classpath" exception as provided
3521 # by Oracle in the LICENSE file that accompanied this code.
3522 #
3523 # This code is distributed in the hope that it will be useful, but WITHOUT
3524 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3525 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3526 # version 2 for more details (a copy is included in the LICENSE file that
3527 # accompanied this code).
3528 #
3529 # You should have received a copy of the GNU General Public License version
3530 # 2 along with this work; if not, write to the Free Software Foundation,
3531 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3532 #
3533 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3534 # or visit www.oracle.com if you need additional information or have any
3535 # questions.
3536 #
3537 
3538 # Create a function/macro that takes a series of named arguments. The call is
3539 # similar to AC_DEFUN, but the setup of the function looks like this:
3540 # BASIC_DEFUN_NAMED([MYFUNC], [FOO *BAR], [$@], [
3541 # ... do something
3542 #   AC_MSG_NOTICE([Value of BAR is ARG_BAR])
3543 # ])
3544 # A star (*) in front of a named argument means that it is required and it's
3545 # presence will be verified. To pass e.g. the first value as a normal indexed
3546 # argument, use [m4_shift($@)] as the third argument instead of [$@]. These
3547 # arguments are referenced in the function by their name prefixed by ARG_, e.g.
3548 # "ARG_FOO".
3549 #
3550 # The generated function can be called like this:
3551 # MYFUNC(FOO: [foo-val],
3552 #     BAR: [
3553 #         $ECHO hello world
3554 #     ])
3555 # Note that the argument value must start on the same line as the argument name.
3556 #
3557 # Argument 1: Name of the function to define
3558 # Argument 2: List of legal named arguments, with a * prefix for required arguments
3559 # Argument 3: Argument array to treat as named, typically $@
3560 # Argument 4: The main function body
3561 
3562 
3563 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3564 # If so, then append $1 to $2 \
3565 # Also set JVM_ARG_OK to true/false depending on outcome.
3566 
3567 
3568 # Appends a string to a path variable, only adding the : when needed.
3569 
3570 
3571 # Prepends a string to a path variable, only adding the : when needed.
3572 
3573 
3574 # This will make sure the given variable points to a full and proper
3575 # path. This means:
3576 # 1) There will be no spaces in the path. On unix platforms,
3577 #    spaces in the path will result in an error. On Windows,
3578 #    the path will be rewritten using short-style to be space-free.
3579 # 2) The path will be absolute, and it will be in unix-style (on
3580 #     cygwin).
3581 # $1: The name of the variable to fix
3582 
3583 
3584 # This will make sure the given variable points to a executable
3585 # with a full and proper path. This means:
3586 # 1) There will be no spaces in the path. On unix platforms,
3587 #    spaces in the path will result in an error. On Windows,
3588 #    the path will be rewritten using short-style to be space-free.
3589 # 2) The path will be absolute, and it will be in unix-style (on
3590 #     cygwin).
3591 # Any arguments given to the executable is preserved.
3592 # If the input variable does not have a directory specification, then
3593 # it need to be in the PATH.
3594 # $1: The name of the variable to fix
3595 
3596 
3597 
3598 
3599 # Register a --with argument but mark it as deprecated
3600 # $1: The name of the with argument to deprecate, not including --with-
3601 
3602 
3603 # Register a --enable argument but mark it as deprecated
3604 # $1: The name of the with argument to deprecate, not including --enable-
3605 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3606 # $3: Messages to user.
3607 
3608 
3609 
3610 
3611 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3612 # $1: variable to check
3613 
3614 
3615 # Check that there are no unprocessed overridden variables left.
3616 # If so, they are an incorrect argument and we will exit with an error.
3617 
3618 
3619 # Setup a tool for the given variable. If correctly specified by the user,
3620 # use that value, otherwise search for the tool using the supplied code snippet.
3621 # $1: variable to set
3622 # $2: code snippet to call to look for the tool
3623 # $3: code snippet to call if variable was used to find tool
3624 
3625 
3626 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3627 # $1: variable to set
3628 # $2: executable name (or list of names) to look for
3629 
3630 
3631 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3632 # $1: variable to set
3633 # $2: executable name (or list of names) to look for
3634 
3635 
3636 # Like BASIC_PATH_PROGS but fails if no tool was found.
3637 # $1: variable to set
3638 # $2: executable name (or list of names) to look for
3639 
3640 
3641 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3642 # $1: variable to set
3643 # $2: autoconf macro to call to look for the special tool
3644 
3645 
3646 # Setup the most fundamental tools that relies on not much else to set up,
3647 # but is used by much of the early bootstrap code.
3648 
3649 
3650 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3651 
3652 
3653 # Evaluates platform specific overrides for devkit variables.
3654 # $1: Name of variable
3655 
3656 
3657 
3658 
3659 
3660 
3661 #%%% Simple tools %%%
3662 
3663 # Check if we have found a usable version of make
3664 # $1: the path to a potential make binary (or empty)
3665 # $2: the description on how we found this
3666 
3667 
3668 
3669 
3670 # Goes looking for a usable version of GNU make.
3671 
3672 
3673 
3674 
3675 
3676 
3677 # Check if build directory is on local disk. If not possible to determine,
3678 # we prefer to claim it's local.
3679 # Argument 1: directory to test
3680 # Argument 2: what to do if it is on local disk
3681 # Argument 3: what to do otherwise (remote disk or failure)
3682 
3683 
3684 # Check that source files have basic read permissions set. This might
3685 # not be the case in cygwin in certain conditions.
3686 
3687 
3688 
3689 
3690 # Check for support for specific options in bash
3691 
3692 
3693 ################################################################################
3694 #
3695 # Default make target
3696 #
3697 
3698 
3699 # Code to run after AC_OUTPUT
3700 
3701 
3702 #
3703 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3704 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3705 #
3706 # This code is free software; you can redistribute it and/or modify it
3707 # under the terms of the GNU General Public License version 2 only, as
3708 # published by the Free Software Foundation.  Oracle designates this
3709 # particular file as subject to the "Classpath" exception as provided
3710 # by Oracle in the LICENSE file that accompanied this code.
3711 #
3712 # This code is distributed in the hope that it will be useful, but WITHOUT
3713 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3714 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3715 # version 2 for more details (a copy is included in the LICENSE file that
3716 # accompanied this code).
3717 #
3718 # You should have received a copy of the GNU General Public License version
3719 # 2 along with this work; if not, write to the Free Software Foundation,
3720 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3721 #
3722 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3723 # or visit www.oracle.com if you need additional information or have any
3724 # questions.
3725 #
3726 
3727 
3728 
3729 
3730 
3731 # Helper function which possibly converts a path using DOS-style short mode.
3732 # If so, the updated path is stored in $new_path.
3733 # $1: The path to check
3734 
3735 
3736 # Helper function which possibly converts a path using DOS-style short mode.
3737 # If so, the updated path is stored in $new_path.
3738 # $1: The path to check
3739 
3740 
3741 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3742 # and could probably be heavily simplified. However, all changes in this
3743 # area tend to need lot of testing in different scenarios, and in lack of
3744 # proper unit testing, cleaning this up has not been deemed worth the effort
3745 # at the moment.
3746 
3747 
3748 
3749 
3750 
3751 
3752 
3753 
3754 
3755 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3756 
3757 
3758 
3759 
3760 # ... then the rest
3761 #
3762 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3763 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3764 #
3765 # This code is free software; you can redistribute it and/or modify it
3766 # under the terms of the GNU General Public License version 2 only, as
3767 # published by the Free Software Foundation.  Oracle designates this
3768 # particular file as subject to the "Classpath" exception as provided
3769 # by Oracle in the LICENSE file that accompanied this code.
3770 #
3771 # This code is distributed in the hope that it will be useful, but WITHOUT
3772 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3773 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3774 # version 2 for more details (a copy is included in the LICENSE file that
3775 # accompanied this code).
3776 #
3777 # You should have received a copy of the GNU General Public License version
3778 # 2 along with this work; if not, write to the Free Software Foundation,
3779 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3780 #
3781 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3782 # or visit www.oracle.com if you need additional information or have any
3783 # questions.
3784 #
3785 
3786 ########################################################################
3787 # This file handles detection of the Boot JDK. The Boot JDK detection
3788 # process has been developed as a response to solve a complex real-world
3789 # problem. Initially, it was simple, but it has grown as platform after
3790 # platform, idiosyncracy after idiosyncracy has been supported.
3791 #
3792 # The basic idea is this:
3793 # 1) You need an acceptable *) JDK to use as a Boot JDK
3794 # 2) There are several ways to locate a JDK, that are mostly platform
3795 #    dependent **)
3796 # 3) You can have multiple JDKs installed
3797 # 4) If possible, configure should try to dig out an acceptable JDK
3798 #    automatically, without having to resort to command-line options
3799 #
3800 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3801 #     javac) and not a JRE, etc.
3802 #
3803 # **) On Windows we typically use a well-known path.
3804 #     On MacOSX we typically use the tool java_home.
3805 #     On Linux we typically find javac in the $PATH, and then follow a
3806 #     chain of symlinks that often ends up in a real JDK.
3807 #
3808 # This leads to the code where we check in different ways to locate a
3809 # JDK, and if one is found, check if it is acceptable. If not, we print
3810 # our reasons for rejecting it (useful when debugging non-working
3811 # configure situations) and continue checking the next one.
3812 ########################################################################
3813 
3814 # Execute the check given as argument, and verify the result
3815 # If the Boot JDK was previously found, do nothing
3816 # $1 A command line (typically autoconf macro) to execute
3817 
3818 
3819 # Test: Is bootjdk explicitely set by command line arguments?
3820 
3821 
3822 # Test: Is $JAVA_HOME set?
3823 
3824 
3825 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3826 
3827 
3828 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3829 # $1: Argument to the java_home binary (optional)
3830 
3831 
3832 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3833 
3834 
3835 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3836 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3837 # $1 = Path to directory containing jdk installations.
3838 # $2 = String to append to the found JDK directory to get the proper JDK home
3839 
3840 
3841 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3842 # environmental variable as base for where to look.
3843 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3844 
3845 
3846 # Test: Is there a JDK installed in default, well-known locations?
3847 
3848 
3849 # Check that a command-line tool in the Boot JDK is correct
3850 # $1 = name of variable to assign
3851 # $2 = name of binary
3852 
3853 
3854 ###############################################################################
3855 #
3856 # We need a Boot JDK to bootstrap the build.
3857 #
3858 
3859 
3860 
3861 
3862 
3863 # BUILD_JDK: the location of the latest JDK that can run
3864 #   on the host system and supports the target class file version
3865 #   generated in this JDK build.  This variable should only be
3866 #   used after the launchers are built.
3867 #
3868 
3869 # Execute the check given as argument, and verify the result.
3870 # If the JDK was previously found, do nothing.
3871 # $1 A command line (typically autoconf macro) to execute
3872 
3873 
3874 # By default the BUILD_JDK is the JDK_OUTPUTDIR.  If the target architecture
3875 # is different than the host system doing the build (e.g. cross-compilation),
3876 # a special BUILD_JDK is built as part of the build process.  An external
3877 # prebuilt BUILD_JDK can also be supplied.
3878 
3879 
3880 #
3881 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3882 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3883 #
3884 # This code is free software; you can redistribute it and/or modify it
3885 # under the terms of the GNU General Public License version 2 only, as
3886 # published by the Free Software Foundation.  Oracle designates this
3887 # particular file as subject to the "Classpath" exception as provided
3888 # by Oracle in the LICENSE file that accompanied this code.
3889 #
3890 # This code is distributed in the hope that it will be useful, but WITHOUT
3891 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3892 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3893 # version 2 for more details (a copy is included in the LICENSE file that
3894 # accompanied this code).
3895 #
3896 # You should have received a copy of the GNU General Public License version
3897 # 2 along with this work; if not, write to the Free Software Foundation,
3898 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3899 #
3900 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3901 # or visit www.oracle.com if you need additional information or have any
3902 # questions.
3903 #
3904 
3905 
3906 
3907 
3908 
3909 
3910 
3911 
3912 
3913 
3914 
3915 
3916 
3917 
3918 
3919 
3920 
3921 ################################################################################
3922 #
3923 # Runs icecc-create-env once and prints the error if it fails
3924 #
3925 # $1: arguments to icecc-create-env
3926 # $2: log file
3927 #
3928 
3929 
3930 ################################################################################
3931 #
3932 # Optionally enable distributed compilation of native code using icecc/icecream
3933 #
3934 
3935 
3936 
3937 
3938 
3939 
3940 
3941 #
3942 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
3943 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3944 #
3945 # This code is free software; you can redistribute it and/or modify it
3946 # under the terms of the GNU General Public License version 2 only, as
3947 # published by the Free Software Foundation.  Oracle designates this
3948 # particular file as subject to the "Classpath" exception as provided
3949 # by Oracle in the LICENSE file that accompanied this code.
3950 #
3951 # This code is distributed in the hope that it will be useful, but WITHOUT
3952 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3953 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3954 # version 2 for more details (a copy is included in the LICENSE file that
3955 # accompanied this code).
3956 #
3957 # You should have received a copy of the GNU General Public License version
3958 # 2 along with this work; if not, write to the Free Software Foundation,
3959 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3960 #
3961 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3962 # or visit www.oracle.com if you need additional information or have any
3963 # questions.
3964 #
3965 
3966 # Reset the global CFLAGS/LDFLAGS variables and initialize them with the
3967 # corresponding configure arguments instead
3968 
3969 
3970 # Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
3971 # that configure can use them while detecting compilers.
3972 # TOOLCHAIN_TYPE is available here.
3973 # Param 1 - Optional prefix to all variables. (e.g BUILD_)
3974 
3975 
3976 
3977 
3978 
3979 
3980 # Documentation on common flags used for solstudio in HIGHEST.
3981 #
3982 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3983 #          done with care, there are some assumptions below that need to
3984 #          be understood about the use of pointers, and IEEE behavior.
3985 #
3986 # -fns: Use non-standard floating point mode (not IEEE 754)
3987 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3988 # -fsingle: Use single precision floating point with 'float'
3989 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3990 #   (Source with excessing pointer casting and data access with mixed
3991 #    pointer types are not recommended)
3992 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3993 #   (If you expect perfect errno behavior, do not use this)
3994 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3995 # -xrestrict: Pointer parameters to functions do not overlap
3996 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3997 #    If you pass in multiple pointers to the same data, do not use this)
3998 # -xlibmil: Inline some library routines
3999 #   (If you expect perfect errno behavior, do not use this)
4000 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
4001 #   (If you expect perfect errno behavior, do not use this)
4002 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
4003 
4004     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
4005     # Bug?
4006     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
4007     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
4008     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
4009     #fi
4010 
4011 
4012 
4013 
4014 
4015 
4016 ################################################################################
4017 # $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
4018 #      conditionals against.
4019 # $2 - Optional prefix for each variable defined.
4020 
4021 
4022 # FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4023 #                                  IF_FALSE: [RUN-IF-FALSE])
4024 # ------------------------------------------------------------
4025 # Check that the C compiler supports an argument
4026 
4027 
4028 
4029 
4030 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4031 #                                    IF_FALSE: [RUN-IF-FALSE])
4032 # ------------------------------------------------------------
4033 # Check that the C++ compiler supports an argument
4034 
4035 
4036 
4037 
4038 # FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4039 #                                IF_FALSE: [RUN-IF-FALSE])
4040 # ------------------------------------------------------------
4041 # Check that the C and C++ compilers support an argument
4042 
4043 
4044 
4045 
4046 # FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
4047 #                                   IF_FALSE: [RUN-IF-FALSE])
4048 # ------------------------------------------------------------
4049 # Check that the linker support an argument
4050 
4051 
4052 
4053 
4054 
4055 
4056 
4057 
4058 #
4059 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4060 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4061 #
4062 # This code is free software; you can redistribute it and/or modify it
4063 # under the terms of the GNU General Public License version 2 only, as
4064 # published by the Free Software Foundation.  Oracle designates this
4065 # particular file as subject to the "Classpath" exception as provided
4066 # by Oracle in the LICENSE file that accompanied this code.
4067 #
4068 # This code is distributed in the hope that it will be useful, but WITHOUT
4069 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4070 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4071 # version 2 for more details (a copy is included in the LICENSE file that
4072 # accompanied this code).
4073 #
4074 # You should have received a copy of the GNU General Public License version
4075 # 2 along with this work; if not, write to the Free Software Foundation,
4076 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4077 #
4078 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4079 # or visit www.oracle.com if you need additional information or have any
4080 # questions.
4081 #
4082 
4083 
4084 
4085 
4086 
4087 cygwin_help() {
4088   case $1 in
4089     unzip)
4090       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
4091       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4092       ;;
4093     zip)
4094       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
4095       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4096       ;;
4097     make)
4098       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
4099       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
4100       ;;
4101     freetype)
4102       HELP_MSG="
4103 The freetype library can now be build during the configure process.
4104 Download the freetype sources and unpack them into an arbitrary directory:
4105 
4106 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
4107 tar -xzf freetype-2.5.3.tar.gz
4108 
4109 Then run configure with '--with-freetype-src=<freetype_src>'. This will
4110 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
4111 builds or into '<freetype_src>/lib32' for 32-bit builds.
4112 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
4113 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds.
4114 
4115 Alternatively you can unpack the sources like this to use the default directory:
4116 
4117 tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz"
4118       ;;
4119   esac
4120 }
4121 
4122 msys_help() {
4123   PKGHANDLER_COMMAND=""
4124 }
4125 
4126 apt_help() {
4127   case $1 in
4128     reduced)
4129       PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
4130     devkit)
4131       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
4132     openjdk)
4133       PKGHANDLER_COMMAND="sudo apt-get install openjdk-8-jdk" ;;
4134     alsa)
4135       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
4136     cups)
4137       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
4138     freetype)
4139       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
4140     ffi)
4141       PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
4142     x11)
4143       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
4144     ccache)
4145       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
4146     dtrace)
4147       PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
4148   esac
4149 }
4150 
4151 yum_help() {
4152   case $1 in
4153     devkit)
4154       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
4155     openjdk)
4156       PKGHANDLER_COMMAND="sudo yum install java-1.8.0-openjdk-devel" ;;
4157     alsa)
4158       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
4159     cups)
4160       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
4161     freetype)
4162       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
4163     x11)
4164       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
4165     ccache)
4166       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
4167   esac
4168 }
4169 
4170 port_help() {
4171   PKGHANDLER_COMMAND=""
4172 }
4173 
4174 pkgutil_help() {
4175   PKGHANDLER_COMMAND=""
4176 }
4177 
4178 pkgadd_help() {
4179   PKGHANDLER_COMMAND=""
4180 }
4181 
4182 # This function will check if we're called from the "configure" wrapper while
4183 # printing --help. If so, we will print out additional information that can
4184 # only be extracted within the autoconf script, and then exit. This must be
4185 # called at the very beginning in configure.ac.
4186 
4187 
4188 
4189 
4190 
4191 
4192 #
4193 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4194 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4195 #
4196 # This code is free software; you can redistribute it and/or modify it
4197 # under the terms of the GNU General Public License version 2 only, as
4198 # published by the Free Software Foundation.  Oracle designates this
4199 # particular file as subject to the "Classpath" exception as provided
4200 # by Oracle in the LICENSE file that accompanied this code.
4201 #
4202 # This code is distributed in the hope that it will be useful, but WITHOUT
4203 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4204 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4205 # version 2 for more details (a copy is included in the LICENSE file that
4206 # accompanied this code).
4207 #
4208 # You should have received a copy of the GNU General Public License version
4209 # 2 along with this work; if not, write to the Free Software Foundation,
4210 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4211 #
4212 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4213 # or visit www.oracle.com if you need additional information or have any
4214 # questions.
4215 #
4216 
4217 # All valid JVM features, regardless of platform
4218 VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
4219     fprof vm-structs jni-check services management all-gcs nmt cds static-build"
4220 
4221 # All valid JVM variants
4222 VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
4223 
4224 ###############################################################################
4225 # Check if the specified JVM variant should be built. To be used in shell if
4226 # constructs, like this:
4227 # if HOTSPOT_CHECK_JVM_VARIANT(server); then
4228 #
4229 # Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
4230 
4231 # Definition kept in one line to allow inlining in if statements.
4232 # Additional [] needed to keep m4 from mangling shell constructs.
4233 
4234 
4235 ###############################################################################
4236 # Check if the specified JVM features are explicitly enabled. To be used in
4237 # shell if constructs, like this:
4238 # if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
4239 #
4240 # Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
4241 
4242 # Definition kept in one line to allow inlining in if statements.
4243 # Additional [] needed to keep m4 from mangling shell constructs.
4244 
4245 
4246 ###############################################################################
4247 # Check which variants of the JVM that we want to build. Available variants are:
4248 #   server: normal interpreter, and a tiered C1/C2 compiler
4249 #   client: normal interpreter, and C1 (no C2 compiler)
4250 #   minimal: reduced form of client with optional features stripped out
4251 #   core: normal interpreter only, no compiler
4252 #   zero: C++ based interpreter only, no compiler
4253 #   zeroshark: C++ based interpreter, and a llvm-based compiler
4254 #   custom: baseline JVM with no default features
4255 #
4256 
4257 
4258 ###############################################################################
4259 # Check if dtrace should be enabled and has all prerequisites present.
4260 #
4261 
4262 
4263 ###############################################################################
4264 # Set up all JVM features for each JVM variant.
4265 #
4266 
4267 
4268 ###############################################################################
4269 # Validate JVM features once all setup is complete, including custom setup.
4270 #
4271 
4272 
4273 #
4274 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4275 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4276 #
4277 # This code is free software; you can redistribute it and/or modify it
4278 # under the terms of the GNU General Public License version 2 only, as
4279 # published by the Free Software Foundation.  Oracle designates this
4280 # particular file as subject to the "Classpath" exception as provided
4281 # by Oracle in the LICENSE file that accompanied this code.
4282 #
4283 # This code is distributed in the hope that it will be useful, but WITHOUT
4284 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4285 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4286 # version 2 for more details (a copy is included in the LICENSE file that
4287 # accompanied this code).
4288 #
4289 # You should have received a copy of the GNU General Public License version
4290 # 2 along with this work; if not, write to the Free Software Foundation,
4291 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4292 #
4293 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4294 # or visit www.oracle.com if you need additional information or have any
4295 # questions.
4296 #
4297 
4298 ###############################################################################
4299 # Check which variant of the JDK that we want to build.
4300 # Currently we have:
4301 #    normal:   standard edition
4302 # but the custom make system may add other variants
4303 #
4304 # Effectively the JDK variant gives a name to a specific set of
4305 # modules to compile into the JDK.
4306 
4307 
4308 ###############################################################################
4309 # Set the debug level
4310 #    release: no debug information, all optimizations, no asserts.
4311 #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
4312 #    fastdebug: debug information (-g), all optimizations, all asserts
4313 #    slowdebug: debug information (-g), no optimizations, all asserts
4314 
4315 
4316 ###############################################################################
4317 #
4318 # Should we build only OpenJDK even if closed sources are present?
4319 #
4320 
4321 
4322 
4323 
4324 ###############################################################################
4325 #
4326 # Enable or disable the elliptic curve crypto implementation
4327 #
4328 
4329 
4330 
4331 
4332 ################################################################################
4333 #
4334 # Gcov coverage data for hotspot
4335 #
4336 
4337 
4338 ################################################################################
4339 #
4340 # Static build support.  When enabled will generate static
4341 # libraries instead of shared libraries for all JDK libs.
4342 #
4343 
4344 
4345 ################################################################################
4346 #
4347 # jlink options.
4348 # We always keep packaged modules in JDK image.
4349 #
4350 
4351 
4352 #
4353 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4354 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4355 #
4356 # This code is free software; you can redistribute it and/or modify it
4357 # under the terms of the GNU General Public License version 2 only, as
4358 # published by the Free Software Foundation.  Oracle designates this
4359 # particular file as subject to the "Classpath" exception as provided
4360 # by Oracle in the LICENSE file that accompanied this code.
4361 #
4362 # This code is distributed in the hope that it will be useful, but WITHOUT
4363 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4364 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4365 # version 2 for more details (a copy is included in the LICENSE file that
4366 # accompanied this code).
4367 #
4368 # You should have received a copy of the GNU General Public License version
4369 # 2 along with this work; if not, write to the Free Software Foundation,
4370 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4371 #
4372 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4373 # or visit www.oracle.com if you need additional information or have any
4374 # questions.
4375 #
4376 
4377 ###############################################################################
4378 #
4379 # Setup version numbers
4380 #
4381 
4382 # Verify that a given string represents a valid version number, and assign it
4383 # to a variable.
4384 
4385 # Argument 1: the variable to assign to
4386 # Argument 2: the value given by the user
4387 
4388 
4389 
4390 
4391 #
4392 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4393 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4394 #
4395 # This code is free software; you can redistribute it and/or modify it
4396 # under the terms of the GNU General Public License version 2 only, as
4397 # published by the Free Software Foundation.  Oracle designates this
4398 # particular file as subject to the "Classpath" exception as provided
4399 # by Oracle in the LICENSE file that accompanied this code.
4400 #
4401 # This code is distributed in the hope that it will be useful, but WITHOUT
4402 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4403 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4404 # version 2 for more details (a copy is included in the LICENSE file that
4405 # accompanied this code).
4406 #
4407 # You should have received a copy of the GNU General Public License version
4408 # 2 along with this work; if not, write to the Free Software Foundation,
4409 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4410 #
4411 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4412 # or visit www.oracle.com if you need additional information or have any
4413 # questions.
4414 #
4415 
4416 # Major library component reside in separate files.
4417 #
4418 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4419 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4420 #
4421 # This code is free software; you can redistribute it and/or modify it
4422 # under the terms of the GNU General Public License version 2 only, as
4423 # published by the Free Software Foundation.  Oracle designates this
4424 # particular file as subject to the "Classpath" exception as provided
4425 # by Oracle in the LICENSE file that accompanied this code.
4426 #
4427 # This code is distributed in the hope that it will be useful, but WITHOUT
4428 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4429 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4430 # version 2 for more details (a copy is included in the LICENSE file that
4431 # accompanied this code).
4432 #
4433 # You should have received a copy of the GNU General Public License version
4434 # 2 along with this work; if not, write to the Free Software Foundation,
4435 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4436 #
4437 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4438 # or visit www.oracle.com if you need additional information or have any
4439 # questions.
4440 #
4441 
4442 ################################################################################
4443 # Setup alsa (Advanced Linux Sound Architecture)
4444 ################################################################################
4445 
4446 
4447 #
4448 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4449 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4450 #
4451 # This code is free software; you can redistribute it and/or modify it
4452 # under the terms of the GNU General Public License version 2 only, as
4453 # published by the Free Software Foundation.  Oracle designates this
4454 # particular file as subject to the "Classpath" exception as provided
4455 # by Oracle in the LICENSE file that accompanied this code.
4456 #
4457 # This code is distributed in the hope that it will be useful, but WITHOUT
4458 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4459 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4460 # version 2 for more details (a copy is included in the LICENSE file that
4461 # accompanied this code).
4462 #
4463 # You should have received a copy of the GNU General Public License version
4464 # 2 along with this work; if not, write to the Free Software Foundation,
4465 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4466 #
4467 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4468 # or visit www.oracle.com if you need additional information or have any
4469 # questions.
4470 #
4471 
4472 ################################################################################
4473 # Setup bundled libraries.
4474 #
4475 # For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
4476 # OpenJDK repository. Default is to use these libraries as bundled, but they
4477 # might be replaced by en external version by the user.
4478 ################################################################################
4479 
4480 
4481 ################################################################################
4482 # Setup libjpeg
4483 ################################################################################
4484 
4485 
4486 ################################################################################
4487 # Setup giflib
4488 ################################################################################
4489 
4490 
4491 ################################################################################
4492 # Setup libpng
4493 ################################################################################
4494 
4495 
4496 ################################################################################
4497 # Setup zlib
4498 ################################################################################
4499 
4500 
4501 ################################################################################
4502 # Setup lcms (Little CMS)
4503 ################################################################################
4504 
4505 
4506 #
4507 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4508 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4509 #
4510 # This code is free software; you can redistribute it and/or modify it
4511 # under the terms of the GNU General Public License version 2 only, as
4512 # published by the Free Software Foundation.  Oracle designates this
4513 # particular file as subject to the "Classpath" exception as provided
4514 # by Oracle in the LICENSE file that accompanied this code.
4515 #
4516 # This code is distributed in the hope that it will be useful, but WITHOUT
4517 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4518 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4519 # version 2 for more details (a copy is included in the LICENSE file that
4520 # accompanied this code).
4521 #
4522 # You should have received a copy of the GNU General Public License version
4523 # 2 along with this work; if not, write to the Free Software Foundation,
4524 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4525 #
4526 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4527 # or visit www.oracle.com if you need additional information or have any
4528 # questions.
4529 #
4530 
4531 ################################################################################
4532 # Setup cups (Common Unix Printing System)
4533 ################################################################################
4534 
4535 
4536 #
4537 # Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
4538 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4539 #
4540 # This code is free software; you can redistribute it and/or modify it
4541 # under the terms of the GNU General Public License version 2 only, as
4542 # published by the Free Software Foundation.  Oracle designates this
4543 # particular file as subject to the "Classpath" exception as provided
4544 # by Oracle in the LICENSE file that accompanied this code.
4545 #
4546 # This code is distributed in the hope that it will be useful, but WITHOUT
4547 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4548 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4549 # version 2 for more details (a copy is included in the LICENSE file that
4550 # accompanied this code).
4551 #
4552 # You should have received a copy of the GNU General Public License version
4553 # 2 along with this work; if not, write to the Free Software Foundation,
4554 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4555 #
4556 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4557 # or visit www.oracle.com if you need additional information or have any
4558 # questions.
4559 #
4560 
4561 ################################################################################
4562 # Setup libffi (Foreign Function Interface)
4563 ################################################################################
4564 
4565 
4566 #
4567 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4568 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4569 #
4570 # This code is free software; you can redistribute it and/or modify it
4571 # under the terms of the GNU General Public License version 2 only, as
4572 # published by the Free Software Foundation.  Oracle designates this
4573 # particular file as subject to the "Classpath" exception as provided
4574 # by Oracle in the LICENSE file that accompanied this code.
4575 #
4576 # This code is distributed in the hope that it will be useful, but WITHOUT
4577 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4578 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4579 # version 2 for more details (a copy is included in the LICENSE file that
4580 # accompanied this code).
4581 #
4582 # You should have received a copy of the GNU General Public License version
4583 # 2 along with this work; if not, write to the Free Software Foundation,
4584 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4585 #
4586 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4587 # or visit www.oracle.com if you need additional information or have any
4588 # questions.
4589 #
4590 
4591 ################################################################################
4592 # Build the freetype lib from source
4593 ################################################################################
4594 
4595 
4596 ################################################################################
4597 # Check if a potential freeype library match is correct and usable
4598 ################################################################################
4599 
4600 
4601 ################################################################################
4602 # Setup freetype (The FreeType2 font rendering library)
4603 ################################################################################
4604 
4605 
4606 #
4607 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4608 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4609 #
4610 # This code is free software; you can redistribute it and/or modify it
4611 # under the terms of the GNU General Public License version 2 only, as
4612 # published by the Free Software Foundation.  Oracle designates this
4613 # particular file as subject to the "Classpath" exception as provided
4614 # by Oracle in the LICENSE file that accompanied this code.
4615 #
4616 # This code is distributed in the hope that it will be useful, but WITHOUT
4617 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4618 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4619 # version 2 for more details (a copy is included in the LICENSE file that
4620 # accompanied this code).
4621 #
4622 # You should have received a copy of the GNU General Public License version
4623 # 2 along with this work; if not, write to the Free Software Foundation,
4624 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4625 #
4626 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4627 # or visit www.oracle.com if you need additional information or have any
4628 # questions.
4629 #
4630 
4631 ################################################################################
4632 # Setup the standard C/C++ runtime libraries.
4633 #
4634 # Most importantly, determine if stdc++ should be linked statically or
4635 # dynamically.
4636 ################################################################################
4637 
4638 
4639 #
4640 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4641 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4642 #
4643 # This code is free software; you can redistribute it and/or modify it
4644 # under the terms of the GNU General Public License version 2 only, as
4645 # published by the Free Software Foundation.  Oracle designates this
4646 # particular file as subject to the "Classpath" exception as provided
4647 # by Oracle in the LICENSE file that accompanied this code.
4648 #
4649 # This code is distributed in the hope that it will be useful, but WITHOUT
4650 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4651 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4652 # version 2 for more details (a copy is included in the LICENSE file that
4653 # accompanied this code).
4654 #
4655 # You should have received a copy of the GNU General Public License version
4656 # 2 along with this work; if not, write to the Free Software Foundation,
4657 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4658 #
4659 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4660 # or visit www.oracle.com if you need additional information or have any
4661 # questions.
4662 #
4663 
4664 ################################################################################
4665 # Setup X11 Windows system
4666 ################################################################################
4667 
4668 
4669 
4670 ################################################################################
4671 # Determine which libraries are needed for this configuration
4672 ################################################################################
4673 
4674 
4675 ################################################################################
4676 # Parse library options, and setup needed libraries
4677 ################################################################################
4678 
4679 
4680 ################################################################################
4681 # Setup llvm (Low-Level VM)
4682 ################################################################################
4683 
4684 
4685 ################################################################################
4686 # Setup various libraries, typically small system libraries
4687 ################################################################################
4688 
4689 
4690 #
4691 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4692 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4693 #
4694 # This code is free software; you can redistribute it and/or modify it
4695 # under the terms of the GNU General Public License version 2 only, as
4696 # published by the Free Software Foundation.  Oracle designates this
4697 # particular file as subject to the "Classpath" exception as provided
4698 # by Oracle in the LICENSE file that accompanied this code.
4699 #
4700 # This code is distributed in the hope that it will be useful, but WITHOUT
4701 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4702 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4703 # version 2 for more details (a copy is included in the LICENSE file that
4704 # accompanied this code).
4705 #
4706 # You should have received a copy of the GNU General Public License version
4707 # 2 along with this work; if not, write to the Free Software Foundation,
4708 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4709 #
4710 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4711 # or visit www.oracle.com if you need additional information or have any
4712 # questions.
4713 #
4714 
4715 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4716 # Converts autoconf style CPU name to OpenJDK style, into
4717 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4718 
4719 
4720 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4721 # Converts autoconf style OS name to OpenJDK style, into
4722 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4723 
4724 
4725 # Expects $host_os $host_cpu $build_os and $build_cpu
4726 # and $with_target_bits to have been setup!
4727 #
4728 # Translate the standard triplet(quadruplet) definition
4729 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4730 # OPENJDK_BUILD_OS, etc.
4731 
4732 
4733 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4734 # accordingly. Must be done after setting up build and target system, but before
4735 # doing anything else with these values.
4736 
4737 
4738 # Setup the legacy variables, for controlling the old makefiles.
4739 #
4740 
4741 
4742 # $1 - Either TARGET or BUILD to setup the variables for.
4743 
4744 
4745 
4746 
4747 #%%% Build and target systems %%%
4748 
4749 
4750 
4751 
4752 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4753 # Add -mX to various FLAGS variables.
4754 
4755 
4756 
4757 
4758 
4759 
4760 #
4761 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4762 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4763 #
4764 # This code is free software; you can redistribute it and/or modify it
4765 # under the terms of the GNU General Public License version 2 only, as
4766 # published by the Free Software Foundation.  Oracle designates this
4767 # particular file as subject to the "Classpath" exception as provided
4768 # by Oracle in the LICENSE file that accompanied this code.
4769 #
4770 # This code is distributed in the hope that it will be useful, but WITHOUT
4771 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4772 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4773 # version 2 for more details (a copy is included in the LICENSE file that
4774 # accompanied this code).
4775 #
4776 # You should have received a copy of the GNU General Public License version
4777 # 2 along with this work; if not, write to the Free Software Foundation,
4778 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4779 #
4780 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4781 # or visit www.oracle.com if you need additional information or have any
4782 # questions.
4783 #
4784 
4785 
4786 
4787 
4788 
4789 
4790 
4791 ################################################################################
4792 # Define a mechanism for importing extra prebuilt modules
4793 #
4794 
4795 
4796 
4797 #
4798 # Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
4799 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4800 #
4801 # This code is free software; you can redistribute it and/or modify it
4802 # under the terms of the GNU General Public License version 2 only, as
4803 # published by the Free Software Foundation.  Oracle designates this
4804 # particular file as subject to the "Classpath" exception as provided
4805 # by Oracle in the LICENSE file that accompanied this code.
4806 #
4807 # This code is distributed in the hope that it will be useful, but WITHOUT
4808 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4809 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4810 # version 2 for more details (a copy is included in the LICENSE file that
4811 # accompanied this code).
4812 #
4813 # You should have received a copy of the GNU General Public License version
4814 # 2 along with this work; if not, write to the Free Software Foundation,
4815 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4816 #
4817 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4818 # or visit www.oracle.com if you need additional information or have any
4819 # questions.
4820 #
4821 
4822 ########################################################################
4823 # This file is responsible for detecting, verifying and setting up the
4824 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4825 # proper paths to the binaries, but it will not setup any flags.
4826 #
4827 # The binaries used is determined by the toolchain type, which is the family of
4828 # compilers and related tools that are used.
4829 ########################################################################
4830 
4831 
4832 # All valid toolchains, regardless of platform (used by help.m4)
4833 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4834 
4835 # These toolchains are valid on different platforms
4836 VALID_TOOLCHAINS_linux="gcc clang"
4837 VALID_TOOLCHAINS_solaris="solstudio"
4838 VALID_TOOLCHAINS_macosx="gcc clang"
4839 VALID_TOOLCHAINS_aix="xlc"
4840 VALID_TOOLCHAINS_windows="microsoft"
4841 
4842 # Toolchain descriptions
4843 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4844 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4845 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4846 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4847 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4848 
4849 # Minimum supported versions, empty means unspecified
4850 TOOLCHAIN_MINIMUM_VERSION_clang="3.2"
4851 TOOLCHAIN_MINIMUM_VERSION_gcc="4.3"
4852 TOOLCHAIN_MINIMUM_VERSION_microsoft=""
4853 TOOLCHAIN_MINIMUM_VERSION_solstudio="5.12"
4854 TOOLCHAIN_MINIMUM_VERSION_xlc=""
4855 
4856 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
4857 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
4858 
4859 
4860 # Check if the configured compiler (C and C++) is of a specific version or
4861 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
4862 #
4863 # Arguments:
4864 #   VERSION:   The version string to check against the found version
4865 #   IF_AT_LEAST:   block to run if the compiler is at least this version (>=)
4866 #   IF_OLDER_THAN:   block to run if the compiler is older than this version (<)
4867 
4868 
4869 
4870 
4871 # Setup a number of variables describing how native output files are
4872 # named on this platform/toolchain.
4873 
4874 
4875 # Determine which toolchain type to use, and make sure it is valid for this
4876 # platform. Setup various information about the selected toolchain.
4877 
4878 
4879 # Before we start detecting the toolchain executables, we might need some
4880 # special setup, e.g. additional paths etc.
4881 
4882 
4883 # Restore path, etc
4884 
4885 
4886 # Check if a compiler is of the toolchain type we expect, and save the version
4887 # information from it. If the compiler does not match the expected type,
4888 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4889 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4890 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4891 #
4892 # $1 = compiler to test (CC or CXX)
4893 # $2 = human readable name of compiler (C or C++)
4894 
4895 
4896 # Try to locate the given C or C++ compiler in the path, or otherwise.
4897 #
4898 # $1 = compiler to test (CC or CXX)
4899 # $2 = human readable name of compiler (C or C++)
4900 # $3 = list of compiler names to search for
4901 
4902 
4903 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4904 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4905 # archiver (AR). Verify that the compilers are correct according to the
4906 # toolchain type.
4907 
4908 
4909 # Setup additional tools that is considered a part of the toolchain, but not the
4910 # core part. Many of these are highly platform-specific and do not exist,
4911 # and/or are not needed on all platforms.
4912 
4913 
4914 # Setup the build tools (i.e, the compiler and linker used to build programs
4915 # that should be run on the build platform, not the target platform, as a build
4916 # helper). Since the non-cross-compile case uses the normal, target compilers
4917 # for this, we can only do this after these have been setup.
4918 
4919 
4920 # Setup legacy variables that are still needed as alternative ways to refer to
4921 # parts of the toolchain.
4922 
4923 
4924 # Do some additional checks on the detected tools.
4925 
4926 
4927 # Setup the JTReg Regression Test Harness.
4928 
4929 
4930 #
4931 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4932 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4933 #
4934 # This code is free software; you can redistribute it and/or modify it
4935 # under the terms of the GNU General Public License version 2 only, as
4936 # published by the Free Software Foundation.  Oracle designates this
4937 # particular file as subject to the "Classpath" exception as provided
4938 # by Oracle in the LICENSE file that accompanied this code.
4939 #
4940 # This code is distributed in the hope that it will be useful, but WITHOUT
4941 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4942 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4943 # version 2 for more details (a copy is included in the LICENSE file that
4944 # accompanied this code).
4945 #
4946 # You should have received a copy of the GNU General Public License version
4947 # 2 along with this work; if not, write to the Free Software Foundation,
4948 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4949 #
4950 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4951 # or visit www.oracle.com if you need additional information or have any
4952 # questions.
4953 #
4954 
4955 ################################################################################
4956 # The order of these defines the priority by which we try to find them.
4957 VALID_VS_VERSIONS="2013 2012 2010"
4958 
4959 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4960 VS_VERSION_INTERNAL_2010=100
4961 VS_MSVCR_2010=msvcr100.dll
4962 # We don't use msvcp on Visual Studio 2010
4963 #VS_MSVCP_2010=msvcp100.dll
4964 VS_ENVVAR_2010="VS100COMNTOOLS"
4965 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4966 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4967 VS_VS_PLATFORM_NAME_2010="v100"
4968 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4969 
4970 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4971 VS_VERSION_INTERNAL_2012=110
4972 VS_MSVCR_2012=msvcr110.dll
4973 VS_MSVCP_2012=msvcp110.dll
4974 VS_ENVVAR_2012="VS110COMNTOOLS"
4975 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4976 VS_SDK_INSTALLDIR_2012=
4977 VS_VS_PLATFORM_NAME_2012="v110"
4978 VS_SDK_PLATFORM_NAME_2012=
4979 
4980 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4981 VS_VERSION_INTERNAL_2013=120
4982 VS_MSVCR_2013=msvcr120.dll
4983 VS_MSVCP_2013=msvcp120.dll
4984 VS_ENVVAR_2013="VS120COMNTOOLS"
4985 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4986 VS_SDK_INSTALLDIR_2013=
4987 VS_VS_PLATFORM_NAME_2013="v120"
4988 VS_SDK_PLATFORM_NAME_2013=
4989 
4990 ################################################################################
4991 
4992 
4993 
4994 ################################################################################
4995 
4996 
4997 
4998 ################################################################################
4999 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
5000 # build environment and assigns it to VS_ENV_CMD
5001 
5002 
5003 ################################################################################
5004 
5005 
5006 
5007 ################################################################################
5008 # Check if the VS env variables were setup prior to running configure.
5009 # If not, then find vcvarsall.bat and run it automatically, and integrate
5010 # the set env variables into the spec file.
5011 
5012 
5013 
5014 
5015 
5016 
5017 
5018 
5019 
5020 
5021 
5022 
5023 
5024 
5025 # This line needs to be here, verbatim, after all includes and the dummy hook
5026 # definitions. It is replaced with custom functionality when building
5027 # custom sources.
5028 #CUSTOM_AUTOCONF_INCLUDE
5029 
5030 # Do not change or remove the following line, it is needed for consistency checks:
5031 DATE_WHEN_GENERATED=1461157070
5032 
5033 ###############################################################################
5034 #
5035 # Initialization / Boot-strapping
5036 #
5037 # The bootstrapping process needs to solve the "chicken or the egg" problem,
5038 # thus it jumps back and forth, each time gaining something needed later on.
5039 #
5040 ###############################################################################
5041 
5042 # If we are requested to print additional help, do that and then exit.
5043 # This must be the very first call.
5044 
5045   if test "x$CONFIGURE_PRINT_ADDITIONAL_HELP" != x; then
5046 
5047     # Print available toolchains
5048     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
5049     $PRINTF "Which are valid to use depends on the build platform.\n"
5050     for toolchain in $VALID_TOOLCHAINS_all; do
5051       # Use indirect variable referencing
5052       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
5053       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
5054       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
5055     done
5056     $PRINTF "\n"
5057 
5058     # Print available jvm features
5059     $PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
5060     $PRINTF "Which are valid to use depends on the target platform.\n  "
5061     $PRINTF "%s " $VALID_JVM_FEATURES
5062     $PRINTF "\n"
5063 
5064     # And now exit directly
5065     exit 0
5066   fi
5067 
5068 
5069 # Basic initialization that must happen first of all in the normal process.
5070 
5071   # Save the original command line. This is passed to us by the wrapper configure script.
5072 
5073   # Save the path variable before it gets changed
5074   ORIGINAL_PATH="$PATH"
5075 
5076   DATE_WHEN_CONFIGURED=`LANG=C date`
5077 
5078   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
5079 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
5080   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
5081 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
5082 
5083 
5084   # Start with tools that do not need have cross compilation support
5085   # and can be expected to be found in the default PATH. These tools are
5086   # used by configure.
5087 
5088   # First are all the simple required tools.
5089 
5090 
5091 
5092   # Publish this variable in the help.
5093 
5094 
5095   if [ -z "${BASENAME+x}" ]; then
5096     # The variable is not set by user, try to locate tool using the code snippet
5097     for ac_prog in basename
5098 do
5099   # Extract the first word of "$ac_prog", so it can be a program name with args.
5100 set dummy $ac_prog; ac_word=$2
5101 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5102 $as_echo_n "checking for $ac_word... " >&6; }
5103 if ${ac_cv_path_BASENAME+:} false; then :
5104   $as_echo_n "(cached) " >&6
5105 else
5106   case $BASENAME in
5107   [\\/]* | ?:[\\/]*)
5108   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5109   ;;
5110   *)
5111   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5112 for as_dir in $PATH
5113 do
5114   IFS=$as_save_IFS
5115   test -z "$as_dir" && as_dir=.
5116     for ac_exec_ext in '' $ac_executable_extensions; do
5117   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5118     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5119     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5120     break 2
5121   fi
5122 done
5123   done
5124 IFS=$as_save_IFS
5125 
5126   ;;
5127 esac
5128 fi
5129 BASENAME=$ac_cv_path_BASENAME
5130 if test -n "$BASENAME"; then
5131   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5132 $as_echo "$BASENAME" >&6; }
5133 else
5134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5135 $as_echo "no" >&6; }
5136 fi
5137 
5138 
5139   test -n "$BASENAME" && break
5140 done
5141 
5142   else
5143     # The variable is set, but is it from the command line or the environment?
5144 
5145     # Try to remove the string !BASENAME! from our list.
5146     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
5147     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5148       # If it failed, the variable was not from the command line. Ignore it,
5149       # but warn the user (except for BASH, which is always set by the calling BASH).
5150       if test "xBASENAME" != xBASH; then
5151         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
5152 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
5153       fi
5154       # Try to locate tool using the code snippet
5155       for ac_prog in basename
5156 do
5157   # Extract the first word of "$ac_prog", so it can be a program name with args.
5158 set dummy $ac_prog; ac_word=$2
5159 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5160 $as_echo_n "checking for $ac_word... " >&6; }
5161 if ${ac_cv_path_BASENAME+:} false; then :
5162   $as_echo_n "(cached) " >&6
5163 else
5164   case $BASENAME in
5165   [\\/]* | ?:[\\/]*)
5166   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5167   ;;
5168   *)
5169   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5170 for as_dir in $PATH
5171 do
5172   IFS=$as_save_IFS
5173   test -z "$as_dir" && as_dir=.
5174     for ac_exec_ext in '' $ac_executable_extensions; do
5175   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5176     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5177     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5178     break 2
5179   fi
5180 done
5181   done
5182 IFS=$as_save_IFS
5183 
5184   ;;
5185 esac
5186 fi
5187 BASENAME=$ac_cv_path_BASENAME
5188 if test -n "$BASENAME"; then
5189   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5190 $as_echo "$BASENAME" >&6; }
5191 else
5192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5193 $as_echo "no" >&6; }
5194 fi
5195 
5196 
5197   test -n "$BASENAME" && break
5198 done
5199 
5200     else
5201       # If it succeeded, then it was overridden by the user. We will use it
5202       # for the tool.
5203 
5204       # First remove it from the list of overridden variables, so we can test
5205       # for unknown variables in the end.
5206       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5207 
5208       # Check if we try to supply an empty value
5209       if test "x$BASENAME" = x; then
5210         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
5211 $as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
5212         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5213 $as_echo_n "checking for BASENAME... " >&6; }
5214         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5215 $as_echo "disabled" >&6; }
5216       else
5217         # Check if the provided tool contains a complete path.
5218         tool_specified="$BASENAME"
5219         tool_basename="${tool_specified##*/}"
5220         if test "x$tool_basename" = "x$tool_specified"; then
5221           # A command without a complete path is provided, search $PATH.
5222           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
5223 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
5224           # Extract the first word of "$tool_basename", so it can be a program name with args.
5225 set dummy $tool_basename; ac_word=$2
5226 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5227 $as_echo_n "checking for $ac_word... " >&6; }
5228 if ${ac_cv_path_BASENAME+:} false; then :
5229   $as_echo_n "(cached) " >&6
5230 else
5231   case $BASENAME in
5232   [\\/]* | ?:[\\/]*)
5233   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
5234   ;;
5235   *)
5236   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5237 for as_dir in $PATH
5238 do
5239   IFS=$as_save_IFS
5240   test -z "$as_dir" && as_dir=.
5241     for ac_exec_ext in '' $ac_executable_extensions; do
5242   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5243     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
5244     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5245     break 2
5246   fi
5247 done
5248   done
5249 IFS=$as_save_IFS
5250 
5251   ;;
5252 esac
5253 fi
5254 BASENAME=$ac_cv_path_BASENAME
5255 if test -n "$BASENAME"; then
5256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
5257 $as_echo "$BASENAME" >&6; }
5258 else
5259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5260 $as_echo "no" >&6; }
5261 fi
5262 
5263 
5264           if test "x$BASENAME" = x; then
5265             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5266           fi
5267         else
5268           # Otherwise we believe it is a complete path. Use it as it is.
5269           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
5270 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
5271           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
5272 $as_echo_n "checking for BASENAME... " >&6; }
5273           if test ! -x "$tool_specified"; then
5274             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5275 $as_echo "not found" >&6; }
5276             as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
5277           fi
5278           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5279 $as_echo "$tool_specified" >&6; }
5280         fi
5281       fi
5282     fi
5283 
5284   fi
5285 
5286 
5287 
5288   if test "x$BASENAME" = x; then
5289     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
5290   fi
5291 
5292 
5293 
5294 
5295 
5296   # Publish this variable in the help.
5297 
5298 
5299   if [ -z "${BASH+x}" ]; then
5300     # The variable is not set by user, try to locate tool using the code snippet
5301     for ac_prog in bash
5302 do
5303   # Extract the first word of "$ac_prog", so it can be a program name with args.
5304 set dummy $ac_prog; ac_word=$2
5305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5306 $as_echo_n "checking for $ac_word... " >&6; }
5307 if ${ac_cv_path_BASH+:} false; then :
5308   $as_echo_n "(cached) " >&6
5309 else
5310   case $BASH in
5311   [\\/]* | ?:[\\/]*)
5312   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5313   ;;
5314   *)
5315   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5316 for as_dir in $PATH
5317 do
5318   IFS=$as_save_IFS
5319   test -z "$as_dir" && as_dir=.
5320     for ac_exec_ext in '' $ac_executable_extensions; do
5321   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5322     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5323     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5324     break 2
5325   fi
5326 done
5327   done
5328 IFS=$as_save_IFS
5329 
5330   ;;
5331 esac
5332 fi
5333 BASH=$ac_cv_path_BASH
5334 if test -n "$BASH"; then
5335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5336 $as_echo "$BASH" >&6; }
5337 else
5338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5339 $as_echo "no" >&6; }
5340 fi
5341 
5342 
5343   test -n "$BASH" && break
5344 done
5345 
5346   else
5347     # The variable is set, but is it from the command line or the environment?
5348 
5349     # Try to remove the string !BASH! from our list.
5350     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
5351     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5352       # If it failed, the variable was not from the command line. Ignore it,
5353       # but warn the user (except for BASH, which is always set by the calling BASH).
5354       if test "xBASH" != xBASH; then
5355         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
5356 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
5357       fi
5358       # Try to locate tool using the code snippet
5359       for ac_prog in bash
5360 do
5361   # Extract the first word of "$ac_prog", so it can be a program name with args.
5362 set dummy $ac_prog; ac_word=$2
5363 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5364 $as_echo_n "checking for $ac_word... " >&6; }
5365 if ${ac_cv_path_BASH+:} false; then :
5366   $as_echo_n "(cached) " >&6
5367 else
5368   case $BASH in
5369   [\\/]* | ?:[\\/]*)
5370   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5371   ;;
5372   *)
5373   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5374 for as_dir in $PATH
5375 do
5376   IFS=$as_save_IFS
5377   test -z "$as_dir" && as_dir=.
5378     for ac_exec_ext in '' $ac_executable_extensions; do
5379   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5380     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5381     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5382     break 2
5383   fi
5384 done
5385   done
5386 IFS=$as_save_IFS
5387 
5388   ;;
5389 esac
5390 fi
5391 BASH=$ac_cv_path_BASH
5392 if test -n "$BASH"; then
5393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5394 $as_echo "$BASH" >&6; }
5395 else
5396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5397 $as_echo "no" >&6; }
5398 fi
5399 
5400 
5401   test -n "$BASH" && break
5402 done
5403 
5404     else
5405       # If it succeeded, then it was overridden by the user. We will use it
5406       # for the tool.
5407 
5408       # First remove it from the list of overridden variables, so we can test
5409       # for unknown variables in the end.
5410       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5411 
5412       # Check if we try to supply an empty value
5413       if test "x$BASH" = x; then
5414         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
5415 $as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
5416         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5417 $as_echo_n "checking for BASH... " >&6; }
5418         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5419 $as_echo "disabled" >&6; }
5420       else
5421         # Check if the provided tool contains a complete path.
5422         tool_specified="$BASH"
5423         tool_basename="${tool_specified##*/}"
5424         if test "x$tool_basename" = "x$tool_specified"; then
5425           # A command without a complete path is provided, search $PATH.
5426           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
5427 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
5428           # Extract the first word of "$tool_basename", so it can be a program name with args.
5429 set dummy $tool_basename; ac_word=$2
5430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5431 $as_echo_n "checking for $ac_word... " >&6; }
5432 if ${ac_cv_path_BASH+:} false; then :
5433   $as_echo_n "(cached) " >&6
5434 else
5435   case $BASH in
5436   [\\/]* | ?:[\\/]*)
5437   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
5438   ;;
5439   *)
5440   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5441 for as_dir in $PATH
5442 do
5443   IFS=$as_save_IFS
5444   test -z "$as_dir" && as_dir=.
5445     for ac_exec_ext in '' $ac_executable_extensions; do
5446   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5447     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
5448     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5449     break 2
5450   fi
5451 done
5452   done
5453 IFS=$as_save_IFS
5454 
5455   ;;
5456 esac
5457 fi
5458 BASH=$ac_cv_path_BASH
5459 if test -n "$BASH"; then
5460   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
5461 $as_echo "$BASH" >&6; }
5462 else
5463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5464 $as_echo "no" >&6; }
5465 fi
5466 
5467 
5468           if test "x$BASH" = x; then
5469             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5470           fi
5471         else
5472           # Otherwise we believe it is a complete path. Use it as it is.
5473           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
5474 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
5475           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
5476 $as_echo_n "checking for BASH... " >&6; }
5477           if test ! -x "$tool_specified"; then
5478             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5479 $as_echo "not found" >&6; }
5480             as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
5481           fi
5482           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5483 $as_echo "$tool_specified" >&6; }
5484         fi
5485       fi
5486     fi
5487 
5488   fi
5489 
5490 
5491 
5492   if test "x$BASH" = x; then
5493     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
5494   fi
5495 
5496 
5497 
5498 
5499 
5500   # Publish this variable in the help.
5501 
5502 
5503   if [ -z "${CAT+x}" ]; then
5504     # The variable is not set by user, try to locate tool using the code snippet
5505     for ac_prog in cat
5506 do
5507   # Extract the first word of "$ac_prog", so it can be a program name with args.
5508 set dummy $ac_prog; ac_word=$2
5509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5510 $as_echo_n "checking for $ac_word... " >&6; }
5511 if ${ac_cv_path_CAT+:} false; then :
5512   $as_echo_n "(cached) " >&6
5513 else
5514   case $CAT in
5515   [\\/]* | ?:[\\/]*)
5516   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5517   ;;
5518   *)
5519   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5520 for as_dir in $PATH
5521 do
5522   IFS=$as_save_IFS
5523   test -z "$as_dir" && as_dir=.
5524     for ac_exec_ext in '' $ac_executable_extensions; do
5525   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5526     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5527     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5528     break 2
5529   fi
5530 done
5531   done
5532 IFS=$as_save_IFS
5533 
5534   ;;
5535 esac
5536 fi
5537 CAT=$ac_cv_path_CAT
5538 if test -n "$CAT"; then
5539   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5540 $as_echo "$CAT" >&6; }
5541 else
5542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5543 $as_echo "no" >&6; }
5544 fi
5545 
5546 
5547   test -n "$CAT" && break
5548 done
5549 
5550   else
5551     # The variable is set, but is it from the command line or the environment?
5552 
5553     # Try to remove the string !CAT! from our list.
5554     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
5555     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5556       # If it failed, the variable was not from the command line. Ignore it,
5557       # but warn the user (except for BASH, which is always set by the calling BASH).
5558       if test "xCAT" != xBASH; then
5559         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
5560 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
5561       fi
5562       # Try to locate tool using the code snippet
5563       for ac_prog in cat
5564 do
5565   # Extract the first word of "$ac_prog", so it can be a program name with args.
5566 set dummy $ac_prog; ac_word=$2
5567 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5568 $as_echo_n "checking for $ac_word... " >&6; }
5569 if ${ac_cv_path_CAT+:} false; then :
5570   $as_echo_n "(cached) " >&6
5571 else
5572   case $CAT in
5573   [\\/]* | ?:[\\/]*)
5574   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5575   ;;
5576   *)
5577   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5578 for as_dir in $PATH
5579 do
5580   IFS=$as_save_IFS
5581   test -z "$as_dir" && as_dir=.
5582     for ac_exec_ext in '' $ac_executable_extensions; do
5583   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5584     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5585     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5586     break 2
5587   fi
5588 done
5589   done
5590 IFS=$as_save_IFS
5591 
5592   ;;
5593 esac
5594 fi
5595 CAT=$ac_cv_path_CAT
5596 if test -n "$CAT"; then
5597   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5598 $as_echo "$CAT" >&6; }
5599 else
5600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5601 $as_echo "no" >&6; }
5602 fi
5603 
5604 
5605   test -n "$CAT" && break
5606 done
5607 
5608     else
5609       # If it succeeded, then it was overridden by the user. We will use it
5610       # for the tool.
5611 
5612       # First remove it from the list of overridden variables, so we can test
5613       # for unknown variables in the end.
5614       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5615 
5616       # Check if we try to supply an empty value
5617       if test "x$CAT" = x; then
5618         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
5619 $as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
5620         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5621 $as_echo_n "checking for CAT... " >&6; }
5622         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5623 $as_echo "disabled" >&6; }
5624       else
5625         # Check if the provided tool contains a complete path.
5626         tool_specified="$CAT"
5627         tool_basename="${tool_specified##*/}"
5628         if test "x$tool_basename" = "x$tool_specified"; then
5629           # A command without a complete path is provided, search $PATH.
5630           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
5631 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
5632           # Extract the first word of "$tool_basename", so it can be a program name with args.
5633 set dummy $tool_basename; ac_word=$2
5634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5635 $as_echo_n "checking for $ac_word... " >&6; }
5636 if ${ac_cv_path_CAT+:} false; then :
5637   $as_echo_n "(cached) " >&6
5638 else
5639   case $CAT in
5640   [\\/]* | ?:[\\/]*)
5641   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
5642   ;;
5643   *)
5644   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5645 for as_dir in $PATH
5646 do
5647   IFS=$as_save_IFS
5648   test -z "$as_dir" && as_dir=.
5649     for ac_exec_ext in '' $ac_executable_extensions; do
5650   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5651     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
5652     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5653     break 2
5654   fi
5655 done
5656   done
5657 IFS=$as_save_IFS
5658 
5659   ;;
5660 esac
5661 fi
5662 CAT=$ac_cv_path_CAT
5663 if test -n "$CAT"; then
5664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
5665 $as_echo "$CAT" >&6; }
5666 else
5667   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5668 $as_echo "no" >&6; }
5669 fi
5670 
5671 
5672           if test "x$CAT" = x; then
5673             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5674           fi
5675         else
5676           # Otherwise we believe it is a complete path. Use it as it is.
5677           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
5678 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
5679           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
5680 $as_echo_n "checking for CAT... " >&6; }
5681           if test ! -x "$tool_specified"; then
5682             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5683 $as_echo "not found" >&6; }
5684             as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
5685           fi
5686           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5687 $as_echo "$tool_specified" >&6; }
5688         fi
5689       fi
5690     fi
5691 
5692   fi
5693 
5694 
5695 
5696   if test "x$CAT" = x; then
5697     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5698   fi
5699 
5700 
5701 
5702 
5703 
5704   # Publish this variable in the help.
5705 
5706 
5707   if [ -z "${CHMOD+x}" ]; then
5708     # The variable is not set by user, try to locate tool using the code snippet
5709     for ac_prog in chmod
5710 do
5711   # Extract the first word of "$ac_prog", so it can be a program name with args.
5712 set dummy $ac_prog; ac_word=$2
5713 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5714 $as_echo_n "checking for $ac_word... " >&6; }
5715 if ${ac_cv_path_CHMOD+:} false; then :
5716   $as_echo_n "(cached) " >&6
5717 else
5718   case $CHMOD in
5719   [\\/]* | ?:[\\/]*)
5720   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5721   ;;
5722   *)
5723   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5724 for as_dir in $PATH
5725 do
5726   IFS=$as_save_IFS
5727   test -z "$as_dir" && as_dir=.
5728     for ac_exec_ext in '' $ac_executable_extensions; do
5729   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5730     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5731     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5732     break 2
5733   fi
5734 done
5735   done
5736 IFS=$as_save_IFS
5737 
5738   ;;
5739 esac
5740 fi
5741 CHMOD=$ac_cv_path_CHMOD
5742 if test -n "$CHMOD"; then
5743   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5744 $as_echo "$CHMOD" >&6; }
5745 else
5746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5747 $as_echo "no" >&6; }
5748 fi
5749 
5750 
5751   test -n "$CHMOD" && break
5752 done
5753 
5754   else
5755     # The variable is set, but is it from the command line or the environment?
5756 
5757     # Try to remove the string !CHMOD! from our list.
5758     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5759     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5760       # If it failed, the variable was not from the command line. Ignore it,
5761       # but warn the user (except for BASH, which is always set by the calling BASH).
5762       if test "xCHMOD" != xBASH; then
5763         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5764 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5765       fi
5766       # Try to locate tool using the code snippet
5767       for ac_prog in chmod
5768 do
5769   # Extract the first word of "$ac_prog", so it can be a program name with args.
5770 set dummy $ac_prog; ac_word=$2
5771 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5772 $as_echo_n "checking for $ac_word... " >&6; }
5773 if ${ac_cv_path_CHMOD+:} false; then :
5774   $as_echo_n "(cached) " >&6
5775 else
5776   case $CHMOD in
5777   [\\/]* | ?:[\\/]*)
5778   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5779   ;;
5780   *)
5781   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5782 for as_dir in $PATH
5783 do
5784   IFS=$as_save_IFS
5785   test -z "$as_dir" && as_dir=.
5786     for ac_exec_ext in '' $ac_executable_extensions; do
5787   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5788     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5789     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5790     break 2
5791   fi
5792 done
5793   done
5794 IFS=$as_save_IFS
5795 
5796   ;;
5797 esac
5798 fi
5799 CHMOD=$ac_cv_path_CHMOD
5800 if test -n "$CHMOD"; then
5801   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5802 $as_echo "$CHMOD" >&6; }
5803 else
5804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5805 $as_echo "no" >&6; }
5806 fi
5807 
5808 
5809   test -n "$CHMOD" && break
5810 done
5811 
5812     else
5813       # If it succeeded, then it was overridden by the user. We will use it
5814       # for the tool.
5815 
5816       # First remove it from the list of overridden variables, so we can test
5817       # for unknown variables in the end.
5818       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5819 
5820       # Check if we try to supply an empty value
5821       if test "x$CHMOD" = x; then
5822         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
5823 $as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
5824         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5825 $as_echo_n "checking for CHMOD... " >&6; }
5826         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
5827 $as_echo "disabled" >&6; }
5828       else
5829         # Check if the provided tool contains a complete path.
5830         tool_specified="$CHMOD"
5831         tool_basename="${tool_specified##*/}"
5832         if test "x$tool_basename" = "x$tool_specified"; then
5833           # A command without a complete path is provided, search $PATH.
5834           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5835 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5836           # Extract the first word of "$tool_basename", so it can be a program name with args.
5837 set dummy $tool_basename; ac_word=$2
5838 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5839 $as_echo_n "checking for $ac_word... " >&6; }
5840 if ${ac_cv_path_CHMOD+:} false; then :
5841   $as_echo_n "(cached) " >&6
5842 else
5843   case $CHMOD in
5844   [\\/]* | ?:[\\/]*)
5845   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5846   ;;
5847   *)
5848   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5849 for as_dir in $PATH
5850 do
5851   IFS=$as_save_IFS
5852   test -z "$as_dir" && as_dir=.
5853     for ac_exec_ext in '' $ac_executable_extensions; do
5854   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5855     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5856     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5857     break 2
5858   fi
5859 done
5860   done
5861 IFS=$as_save_IFS
5862 
5863   ;;
5864 esac
5865 fi
5866 CHMOD=$ac_cv_path_CHMOD
5867 if test -n "$CHMOD"; then
5868   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5869 $as_echo "$CHMOD" >&6; }
5870 else
5871   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5872 $as_echo "no" >&6; }
5873 fi
5874 
5875 
5876           if test "x$CHMOD" = x; then
5877             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5878           fi
5879         else
5880           # Otherwise we believe it is a complete path. Use it as it is.
5881           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5882 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5883           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5884 $as_echo_n "checking for CHMOD... " >&6; }
5885           if test ! -x "$tool_specified"; then
5886             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5887 $as_echo "not found" >&6; }
5888             as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5889           fi
5890           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5891 $as_echo "$tool_specified" >&6; }
5892         fi
5893       fi
5894     fi
5895 
5896   fi
5897 
5898 
5899 
5900   if test "x$CHMOD" = x; then
5901     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5902   fi
5903 
5904 
5905 
5906 
5907 
5908   # Publish this variable in the help.
5909 
5910 
5911   if [ -z "${CMP+x}" ]; then
5912     # The variable is not set by user, try to locate tool using the code snippet
5913     for ac_prog in cmp
5914 do
5915   # Extract the first word of "$ac_prog", so it can be a program name with args.
5916 set dummy $ac_prog; ac_word=$2
5917 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5918 $as_echo_n "checking for $ac_word... " >&6; }
5919 if ${ac_cv_path_CMP+:} false; then :
5920   $as_echo_n "(cached) " >&6
5921 else
5922   case $CMP in
5923   [\\/]* | ?:[\\/]*)
5924   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5925   ;;
5926   *)
5927   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5928 for as_dir in $PATH
5929 do
5930   IFS=$as_save_IFS
5931   test -z "$as_dir" && as_dir=.
5932     for ac_exec_ext in '' $ac_executable_extensions; do
5933   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5934     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5935     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5936     break 2
5937   fi
5938 done
5939   done
5940 IFS=$as_save_IFS
5941 
5942   ;;
5943 esac
5944 fi
5945 CMP=$ac_cv_path_CMP
5946 if test -n "$CMP"; then
5947   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5948 $as_echo "$CMP" >&6; }
5949 else
5950   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5951 $as_echo "no" >&6; }
5952 fi
5953 
5954 
5955   test -n "$CMP" && break
5956 done
5957 
5958   else
5959     # The variable is set, but is it from the command line or the environment?
5960 
5961     # Try to remove the string !CMP! from our list.
5962     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5963     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5964       # If it failed, the variable was not from the command line. Ignore it,
5965       # but warn the user (except for BASH, which is always set by the calling BASH).
5966       if test "xCMP" != xBASH; then
5967         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5968 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5969       fi
5970       # Try to locate tool using the code snippet
5971       for ac_prog in cmp
5972 do
5973   # Extract the first word of "$ac_prog", so it can be a program name with args.
5974 set dummy $ac_prog; ac_word=$2
5975 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5976 $as_echo_n "checking for $ac_word... " >&6; }
5977 if ${ac_cv_path_CMP+:} false; then :
5978   $as_echo_n "(cached) " >&6
5979 else
5980   case $CMP in
5981   [\\/]* | ?:[\\/]*)
5982   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5983   ;;
5984   *)
5985   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5986 for as_dir in $PATH
5987 do
5988   IFS=$as_save_IFS
5989   test -z "$as_dir" && as_dir=.
5990     for ac_exec_ext in '' $ac_executable_extensions; do
5991   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5992     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5993     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5994     break 2
5995   fi
5996 done
5997   done
5998 IFS=$as_save_IFS
5999 
6000   ;;
6001 esac
6002 fi
6003 CMP=$ac_cv_path_CMP
6004 if test -n "$CMP"; then
6005   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6006 $as_echo "$CMP" >&6; }
6007 else
6008   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6009 $as_echo "no" >&6; }
6010 fi
6011 
6012 
6013   test -n "$CMP" && break
6014 done
6015 
6016     else
6017       # If it succeeded, then it was overridden by the user. We will use it
6018       # for the tool.
6019 
6020       # First remove it from the list of overridden variables, so we can test
6021       # for unknown variables in the end.
6022       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6023 
6024       # Check if we try to supply an empty value
6025       if test "x$CMP" = x; then
6026         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
6027 $as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
6028         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6029 $as_echo_n "checking for CMP... " >&6; }
6030         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6031 $as_echo "disabled" >&6; }
6032       else
6033         # Check if the provided tool contains a complete path.
6034         tool_specified="$CMP"
6035         tool_basename="${tool_specified##*/}"
6036         if test "x$tool_basename" = "x$tool_specified"; then
6037           # A command without a complete path is provided, search $PATH.
6038           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
6039 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
6040           # Extract the first word of "$tool_basename", so it can be a program name with args.
6041 set dummy $tool_basename; ac_word=$2
6042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6043 $as_echo_n "checking for $ac_word... " >&6; }
6044 if ${ac_cv_path_CMP+:} false; then :
6045   $as_echo_n "(cached) " >&6
6046 else
6047   case $CMP in
6048   [\\/]* | ?:[\\/]*)
6049   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
6050   ;;
6051   *)
6052   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6053 for as_dir in $PATH
6054 do
6055   IFS=$as_save_IFS
6056   test -z "$as_dir" && as_dir=.
6057     for ac_exec_ext in '' $ac_executable_extensions; do
6058   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6059     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
6060     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6061     break 2
6062   fi
6063 done
6064   done
6065 IFS=$as_save_IFS
6066 
6067   ;;
6068 esac
6069 fi
6070 CMP=$ac_cv_path_CMP
6071 if test -n "$CMP"; then
6072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
6073 $as_echo "$CMP" >&6; }
6074 else
6075   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6076 $as_echo "no" >&6; }
6077 fi
6078 
6079 
6080           if test "x$CMP" = x; then
6081             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6082           fi
6083         else
6084           # Otherwise we believe it is a complete path. Use it as it is.
6085           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
6086 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
6087           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
6088 $as_echo_n "checking for CMP... " >&6; }
6089           if test ! -x "$tool_specified"; then
6090             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6091 $as_echo "not found" >&6; }
6092             as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
6093           fi
6094           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6095 $as_echo "$tool_specified" >&6; }
6096         fi
6097       fi
6098     fi
6099 
6100   fi
6101 
6102 
6103 
6104   if test "x$CMP" = x; then
6105     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
6106   fi
6107 
6108 
6109 
6110 
6111 
6112   # Publish this variable in the help.
6113 
6114 
6115   if [ -z "${COMM+x}" ]; then
6116     # The variable is not set by user, try to locate tool using the code snippet
6117     for ac_prog in comm
6118 do
6119   # Extract the first word of "$ac_prog", so it can be a program name with args.
6120 set dummy $ac_prog; ac_word=$2
6121 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6122 $as_echo_n "checking for $ac_word... " >&6; }
6123 if ${ac_cv_path_COMM+:} false; then :
6124   $as_echo_n "(cached) " >&6
6125 else
6126   case $COMM in
6127   [\\/]* | ?:[\\/]*)
6128   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6129   ;;
6130   *)
6131   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6132 for as_dir in $PATH
6133 do
6134   IFS=$as_save_IFS
6135   test -z "$as_dir" && as_dir=.
6136     for ac_exec_ext in '' $ac_executable_extensions; do
6137   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6138     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6139     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6140     break 2
6141   fi
6142 done
6143   done
6144 IFS=$as_save_IFS
6145 
6146   ;;
6147 esac
6148 fi
6149 COMM=$ac_cv_path_COMM
6150 if test -n "$COMM"; then
6151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6152 $as_echo "$COMM" >&6; }
6153 else
6154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6155 $as_echo "no" >&6; }
6156 fi
6157 
6158 
6159   test -n "$COMM" && break
6160 done
6161 
6162   else
6163     # The variable is set, but is it from the command line or the environment?
6164 
6165     # Try to remove the string !COMM! from our list.
6166     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
6167     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6168       # If it failed, the variable was not from the command line. Ignore it,
6169       # but warn the user (except for BASH, which is always set by the calling BASH).
6170       if test "xCOMM" != xBASH; then
6171         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
6172 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
6173       fi
6174       # Try to locate tool using the code snippet
6175       for ac_prog in comm
6176 do
6177   # Extract the first word of "$ac_prog", so it can be a program name with args.
6178 set dummy $ac_prog; ac_word=$2
6179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6180 $as_echo_n "checking for $ac_word... " >&6; }
6181 if ${ac_cv_path_COMM+:} false; then :
6182   $as_echo_n "(cached) " >&6
6183 else
6184   case $COMM in
6185   [\\/]* | ?:[\\/]*)
6186   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6187   ;;
6188   *)
6189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6190 for as_dir in $PATH
6191 do
6192   IFS=$as_save_IFS
6193   test -z "$as_dir" && as_dir=.
6194     for ac_exec_ext in '' $ac_executable_extensions; do
6195   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6196     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6197     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6198     break 2
6199   fi
6200 done
6201   done
6202 IFS=$as_save_IFS
6203 
6204   ;;
6205 esac
6206 fi
6207 COMM=$ac_cv_path_COMM
6208 if test -n "$COMM"; then
6209   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6210 $as_echo "$COMM" >&6; }
6211 else
6212   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6213 $as_echo "no" >&6; }
6214 fi
6215 
6216 
6217   test -n "$COMM" && break
6218 done
6219 
6220     else
6221       # If it succeeded, then it was overridden by the user. We will use it
6222       # for the tool.
6223 
6224       # First remove it from the list of overridden variables, so we can test
6225       # for unknown variables in the end.
6226       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6227 
6228       # Check if we try to supply an empty value
6229       if test "x$COMM" = x; then
6230         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
6231 $as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
6232         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6233 $as_echo_n "checking for COMM... " >&6; }
6234         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6235 $as_echo "disabled" >&6; }
6236       else
6237         # Check if the provided tool contains a complete path.
6238         tool_specified="$COMM"
6239         tool_basename="${tool_specified##*/}"
6240         if test "x$tool_basename" = "x$tool_specified"; then
6241           # A command without a complete path is provided, search $PATH.
6242           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
6243 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
6244           # Extract the first word of "$tool_basename", so it can be a program name with args.
6245 set dummy $tool_basename; ac_word=$2
6246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6247 $as_echo_n "checking for $ac_word... " >&6; }
6248 if ${ac_cv_path_COMM+:} false; then :
6249   $as_echo_n "(cached) " >&6
6250 else
6251   case $COMM in
6252   [\\/]* | ?:[\\/]*)
6253   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
6254   ;;
6255   *)
6256   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6257 for as_dir in $PATH
6258 do
6259   IFS=$as_save_IFS
6260   test -z "$as_dir" && as_dir=.
6261     for ac_exec_ext in '' $ac_executable_extensions; do
6262   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6263     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
6264     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6265     break 2
6266   fi
6267 done
6268   done
6269 IFS=$as_save_IFS
6270 
6271   ;;
6272 esac
6273 fi
6274 COMM=$ac_cv_path_COMM
6275 if test -n "$COMM"; then
6276   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
6277 $as_echo "$COMM" >&6; }
6278 else
6279   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6280 $as_echo "no" >&6; }
6281 fi
6282 
6283 
6284           if test "x$COMM" = x; then
6285             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6286           fi
6287         else
6288           # Otherwise we believe it is a complete path. Use it as it is.
6289           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
6290 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
6291           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
6292 $as_echo_n "checking for COMM... " >&6; }
6293           if test ! -x "$tool_specified"; then
6294             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6295 $as_echo "not found" >&6; }
6296             as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
6297           fi
6298           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6299 $as_echo "$tool_specified" >&6; }
6300         fi
6301       fi
6302     fi
6303 
6304   fi
6305 
6306 
6307 
6308   if test "x$COMM" = x; then
6309     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
6310   fi
6311 
6312 
6313 
6314 
6315 
6316   # Publish this variable in the help.
6317 
6318 
6319   if [ -z "${CP+x}" ]; then
6320     # The variable is not set by user, try to locate tool using the code snippet
6321     for ac_prog in cp
6322 do
6323   # Extract the first word of "$ac_prog", so it can be a program name with args.
6324 set dummy $ac_prog; ac_word=$2
6325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6326 $as_echo_n "checking for $ac_word... " >&6; }
6327 if ${ac_cv_path_CP+:} false; then :
6328   $as_echo_n "(cached) " >&6
6329 else
6330   case $CP in
6331   [\\/]* | ?:[\\/]*)
6332   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6333   ;;
6334   *)
6335   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6336 for as_dir in $PATH
6337 do
6338   IFS=$as_save_IFS
6339   test -z "$as_dir" && as_dir=.
6340     for ac_exec_ext in '' $ac_executable_extensions; do
6341   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6342     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6343     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6344     break 2
6345   fi
6346 done
6347   done
6348 IFS=$as_save_IFS
6349 
6350   ;;
6351 esac
6352 fi
6353 CP=$ac_cv_path_CP
6354 if test -n "$CP"; then
6355   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6356 $as_echo "$CP" >&6; }
6357 else
6358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6359 $as_echo "no" >&6; }
6360 fi
6361 
6362 
6363   test -n "$CP" && break
6364 done
6365 
6366   else
6367     # The variable is set, but is it from the command line or the environment?
6368 
6369     # Try to remove the string !CP! from our list.
6370     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
6371     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6372       # If it failed, the variable was not from the command line. Ignore it,
6373       # but warn the user (except for BASH, which is always set by the calling BASH).
6374       if test "xCP" != xBASH; then
6375         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
6376 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
6377       fi
6378       # Try to locate tool using the code snippet
6379       for ac_prog in cp
6380 do
6381   # Extract the first word of "$ac_prog", so it can be a program name with args.
6382 set dummy $ac_prog; ac_word=$2
6383 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6384 $as_echo_n "checking for $ac_word... " >&6; }
6385 if ${ac_cv_path_CP+:} false; then :
6386   $as_echo_n "(cached) " >&6
6387 else
6388   case $CP in
6389   [\\/]* | ?:[\\/]*)
6390   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6391   ;;
6392   *)
6393   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6394 for as_dir in $PATH
6395 do
6396   IFS=$as_save_IFS
6397   test -z "$as_dir" && as_dir=.
6398     for ac_exec_ext in '' $ac_executable_extensions; do
6399   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6400     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6401     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6402     break 2
6403   fi
6404 done
6405   done
6406 IFS=$as_save_IFS
6407 
6408   ;;
6409 esac
6410 fi
6411 CP=$ac_cv_path_CP
6412 if test -n "$CP"; then
6413   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6414 $as_echo "$CP" >&6; }
6415 else
6416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6417 $as_echo "no" >&6; }
6418 fi
6419 
6420 
6421   test -n "$CP" && break
6422 done
6423 
6424     else
6425       # If it succeeded, then it was overridden by the user. We will use it
6426       # for the tool.
6427 
6428       # First remove it from the list of overridden variables, so we can test
6429       # for unknown variables in the end.
6430       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6431 
6432       # Check if we try to supply an empty value
6433       if test "x$CP" = x; then
6434         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
6435 $as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
6436         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6437 $as_echo_n "checking for CP... " >&6; }
6438         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6439 $as_echo "disabled" >&6; }
6440       else
6441         # Check if the provided tool contains a complete path.
6442         tool_specified="$CP"
6443         tool_basename="${tool_specified##*/}"
6444         if test "x$tool_basename" = "x$tool_specified"; then
6445           # A command without a complete path is provided, search $PATH.
6446           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
6447 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
6448           # Extract the first word of "$tool_basename", so it can be a program name with args.
6449 set dummy $tool_basename; ac_word=$2
6450 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6451 $as_echo_n "checking for $ac_word... " >&6; }
6452 if ${ac_cv_path_CP+:} false; then :
6453   $as_echo_n "(cached) " >&6
6454 else
6455   case $CP in
6456   [\\/]* | ?:[\\/]*)
6457   ac_cv_path_CP="$CP" # Let the user override the test with a path.
6458   ;;
6459   *)
6460   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6461 for as_dir in $PATH
6462 do
6463   IFS=$as_save_IFS
6464   test -z "$as_dir" && as_dir=.
6465     for ac_exec_ext in '' $ac_executable_extensions; do
6466   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6467     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
6468     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6469     break 2
6470   fi
6471 done
6472   done
6473 IFS=$as_save_IFS
6474 
6475   ;;
6476 esac
6477 fi
6478 CP=$ac_cv_path_CP
6479 if test -n "$CP"; then
6480   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
6481 $as_echo "$CP" >&6; }
6482 else
6483   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6484 $as_echo "no" >&6; }
6485 fi
6486 
6487 
6488           if test "x$CP" = x; then
6489             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6490           fi
6491         else
6492           # Otherwise we believe it is a complete path. Use it as it is.
6493           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
6494 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
6495           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
6496 $as_echo_n "checking for CP... " >&6; }
6497           if test ! -x "$tool_specified"; then
6498             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6499 $as_echo "not found" >&6; }
6500             as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
6501           fi
6502           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6503 $as_echo "$tool_specified" >&6; }
6504         fi
6505       fi
6506     fi
6507 
6508   fi
6509 
6510 
6511 
6512   if test "x$CP" = x; then
6513     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
6514   fi
6515 
6516 
6517 
6518 
6519 
6520   # Publish this variable in the help.
6521 
6522 
6523   if [ -z "${CUT+x}" ]; then
6524     # The variable is not set by user, try to locate tool using the code snippet
6525     for ac_prog in cut
6526 do
6527   # Extract the first word of "$ac_prog", so it can be a program name with args.
6528 set dummy $ac_prog; ac_word=$2
6529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6530 $as_echo_n "checking for $ac_word... " >&6; }
6531 if ${ac_cv_path_CUT+:} false; then :
6532   $as_echo_n "(cached) " >&6
6533 else
6534   case $CUT in
6535   [\\/]* | ?:[\\/]*)
6536   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6537   ;;
6538   *)
6539   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6540 for as_dir in $PATH
6541 do
6542   IFS=$as_save_IFS
6543   test -z "$as_dir" && as_dir=.
6544     for ac_exec_ext in '' $ac_executable_extensions; do
6545   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6546     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6547     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6548     break 2
6549   fi
6550 done
6551   done
6552 IFS=$as_save_IFS
6553 
6554   ;;
6555 esac
6556 fi
6557 CUT=$ac_cv_path_CUT
6558 if test -n "$CUT"; then
6559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6560 $as_echo "$CUT" >&6; }
6561 else
6562   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6563 $as_echo "no" >&6; }
6564 fi
6565 
6566 
6567   test -n "$CUT" && break
6568 done
6569 
6570   else
6571     # The variable is set, but is it from the command line or the environment?
6572 
6573     # Try to remove the string !CUT! from our list.
6574     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
6575     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6576       # If it failed, the variable was not from the command line. Ignore it,
6577       # but warn the user (except for BASH, which is always set by the calling BASH).
6578       if test "xCUT" != xBASH; then
6579         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
6580 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
6581       fi
6582       # Try to locate tool using the code snippet
6583       for ac_prog in cut
6584 do
6585   # Extract the first word of "$ac_prog", so it can be a program name with args.
6586 set dummy $ac_prog; ac_word=$2
6587 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6588 $as_echo_n "checking for $ac_word... " >&6; }
6589 if ${ac_cv_path_CUT+:} false; then :
6590   $as_echo_n "(cached) " >&6
6591 else
6592   case $CUT in
6593   [\\/]* | ?:[\\/]*)
6594   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6595   ;;
6596   *)
6597   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6598 for as_dir in $PATH
6599 do
6600   IFS=$as_save_IFS
6601   test -z "$as_dir" && as_dir=.
6602     for ac_exec_ext in '' $ac_executable_extensions; do
6603   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6604     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6605     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6606     break 2
6607   fi
6608 done
6609   done
6610 IFS=$as_save_IFS
6611 
6612   ;;
6613 esac
6614 fi
6615 CUT=$ac_cv_path_CUT
6616 if test -n "$CUT"; then
6617   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6618 $as_echo "$CUT" >&6; }
6619 else
6620   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6621 $as_echo "no" >&6; }
6622 fi
6623 
6624 
6625   test -n "$CUT" && break
6626 done
6627 
6628     else
6629       # If it succeeded, then it was overridden by the user. We will use it
6630       # for the tool.
6631 
6632       # First remove it from the list of overridden variables, so we can test
6633       # for unknown variables in the end.
6634       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6635 
6636       # Check if we try to supply an empty value
6637       if test "x$CUT" = x; then
6638         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
6639 $as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
6640         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6641 $as_echo_n "checking for CUT... " >&6; }
6642         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6643 $as_echo "disabled" >&6; }
6644       else
6645         # Check if the provided tool contains a complete path.
6646         tool_specified="$CUT"
6647         tool_basename="${tool_specified##*/}"
6648         if test "x$tool_basename" = "x$tool_specified"; then
6649           # A command without a complete path is provided, search $PATH.
6650           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
6651 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
6652           # Extract the first word of "$tool_basename", so it can be a program name with args.
6653 set dummy $tool_basename; ac_word=$2
6654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6655 $as_echo_n "checking for $ac_word... " >&6; }
6656 if ${ac_cv_path_CUT+:} false; then :
6657   $as_echo_n "(cached) " >&6
6658 else
6659   case $CUT in
6660   [\\/]* | ?:[\\/]*)
6661   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
6662   ;;
6663   *)
6664   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6665 for as_dir in $PATH
6666 do
6667   IFS=$as_save_IFS
6668   test -z "$as_dir" && as_dir=.
6669     for ac_exec_ext in '' $ac_executable_extensions; do
6670   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6671     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
6672     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6673     break 2
6674   fi
6675 done
6676   done
6677 IFS=$as_save_IFS
6678 
6679   ;;
6680 esac
6681 fi
6682 CUT=$ac_cv_path_CUT
6683 if test -n "$CUT"; then
6684   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6685 $as_echo "$CUT" >&6; }
6686 else
6687   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6688 $as_echo "no" >&6; }
6689 fi
6690 
6691 
6692           if test "x$CUT" = x; then
6693             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6694           fi
6695         else
6696           # Otherwise we believe it is a complete path. Use it as it is.
6697           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6698 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6699           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6700 $as_echo_n "checking for CUT... " >&6; }
6701           if test ! -x "$tool_specified"; then
6702             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6703 $as_echo "not found" >&6; }
6704             as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6705           fi
6706           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6707 $as_echo "$tool_specified" >&6; }
6708         fi
6709       fi
6710     fi
6711 
6712   fi
6713 
6714 
6715 
6716   if test "x$CUT" = x; then
6717     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6718   fi
6719 
6720 
6721 
6722 
6723 
6724   # Publish this variable in the help.
6725 
6726 
6727   if [ -z "${DATE+x}" ]; then
6728     # The variable is not set by user, try to locate tool using the code snippet
6729     for ac_prog in date
6730 do
6731   # Extract the first word of "$ac_prog", so it can be a program name with args.
6732 set dummy $ac_prog; ac_word=$2
6733 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6734 $as_echo_n "checking for $ac_word... " >&6; }
6735 if ${ac_cv_path_DATE+:} false; then :
6736   $as_echo_n "(cached) " >&6
6737 else
6738   case $DATE in
6739   [\\/]* | ?:[\\/]*)
6740   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6741   ;;
6742   *)
6743   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6744 for as_dir in $PATH
6745 do
6746   IFS=$as_save_IFS
6747   test -z "$as_dir" && as_dir=.
6748     for ac_exec_ext in '' $ac_executable_extensions; do
6749   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6750     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6751     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6752     break 2
6753   fi
6754 done
6755   done
6756 IFS=$as_save_IFS
6757 
6758   ;;
6759 esac
6760 fi
6761 DATE=$ac_cv_path_DATE
6762 if test -n "$DATE"; then
6763   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6764 $as_echo "$DATE" >&6; }
6765 else
6766   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6767 $as_echo "no" >&6; }
6768 fi
6769 
6770 
6771   test -n "$DATE" && break
6772 done
6773 
6774   else
6775     # The variable is set, but is it from the command line or the environment?
6776 
6777     # Try to remove the string !DATE! from our list.
6778     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6779     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6780       # If it failed, the variable was not from the command line. Ignore it,
6781       # but warn the user (except for BASH, which is always set by the calling BASH).
6782       if test "xDATE" != xBASH; then
6783         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6784 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6785       fi
6786       # Try to locate tool using the code snippet
6787       for ac_prog in date
6788 do
6789   # Extract the first word of "$ac_prog", so it can be a program name with args.
6790 set dummy $ac_prog; ac_word=$2
6791 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6792 $as_echo_n "checking for $ac_word... " >&6; }
6793 if ${ac_cv_path_DATE+:} false; then :
6794   $as_echo_n "(cached) " >&6
6795 else
6796   case $DATE in
6797   [\\/]* | ?:[\\/]*)
6798   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6799   ;;
6800   *)
6801   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6802 for as_dir in $PATH
6803 do
6804   IFS=$as_save_IFS
6805   test -z "$as_dir" && as_dir=.
6806     for ac_exec_ext in '' $ac_executable_extensions; do
6807   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6808     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6809     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6810     break 2
6811   fi
6812 done
6813   done
6814 IFS=$as_save_IFS
6815 
6816   ;;
6817 esac
6818 fi
6819 DATE=$ac_cv_path_DATE
6820 if test -n "$DATE"; then
6821   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6822 $as_echo "$DATE" >&6; }
6823 else
6824   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6825 $as_echo "no" >&6; }
6826 fi
6827 
6828 
6829   test -n "$DATE" && break
6830 done
6831 
6832     else
6833       # If it succeeded, then it was overridden by the user. We will use it
6834       # for the tool.
6835 
6836       # First remove it from the list of overridden variables, so we can test
6837       # for unknown variables in the end.
6838       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6839 
6840       # Check if we try to supply an empty value
6841       if test "x$DATE" = x; then
6842         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
6843 $as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
6844         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6845 $as_echo_n "checking for DATE... " >&6; }
6846         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
6847 $as_echo "disabled" >&6; }
6848       else
6849         # Check if the provided tool contains a complete path.
6850         tool_specified="$DATE"
6851         tool_basename="${tool_specified##*/}"
6852         if test "x$tool_basename" = "x$tool_specified"; then
6853           # A command without a complete path is provided, search $PATH.
6854           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6855 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6856           # Extract the first word of "$tool_basename", so it can be a program name with args.
6857 set dummy $tool_basename; ac_word=$2
6858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6859 $as_echo_n "checking for $ac_word... " >&6; }
6860 if ${ac_cv_path_DATE+:} false; then :
6861   $as_echo_n "(cached) " >&6
6862 else
6863   case $DATE in
6864   [\\/]* | ?:[\\/]*)
6865   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6866   ;;
6867   *)
6868   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6869 for as_dir in $PATH
6870 do
6871   IFS=$as_save_IFS
6872   test -z "$as_dir" && as_dir=.
6873     for ac_exec_ext in '' $ac_executable_extensions; do
6874   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6875     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6876     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6877     break 2
6878   fi
6879 done
6880   done
6881 IFS=$as_save_IFS
6882 
6883   ;;
6884 esac
6885 fi
6886 DATE=$ac_cv_path_DATE
6887 if test -n "$DATE"; then
6888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6889 $as_echo "$DATE" >&6; }
6890 else
6891   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6892 $as_echo "no" >&6; }
6893 fi
6894 
6895 
6896           if test "x$DATE" = x; then
6897             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6898           fi
6899         else
6900           # Otherwise we believe it is a complete path. Use it as it is.
6901           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6902 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6903           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6904 $as_echo_n "checking for DATE... " >&6; }
6905           if test ! -x "$tool_specified"; then
6906             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6907 $as_echo "not found" >&6; }
6908             as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6909           fi
6910           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6911 $as_echo "$tool_specified" >&6; }
6912         fi
6913       fi
6914     fi
6915 
6916   fi
6917 
6918 
6919 
6920   if test "x$DATE" = x; then
6921     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6922   fi
6923 
6924 
6925 
6926 
6927 
6928   # Publish this variable in the help.
6929 
6930 
6931   if [ -z "${DIFF+x}" ]; then
6932     # The variable is not set by user, try to locate tool using the code snippet
6933     for ac_prog in gdiff diff
6934 do
6935   # Extract the first word of "$ac_prog", so it can be a program name with args.
6936 set dummy $ac_prog; ac_word=$2
6937 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6938 $as_echo_n "checking for $ac_word... " >&6; }
6939 if ${ac_cv_path_DIFF+:} false; then :
6940   $as_echo_n "(cached) " >&6
6941 else
6942   case $DIFF in
6943   [\\/]* | ?:[\\/]*)
6944   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6945   ;;
6946   *)
6947   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6948 for as_dir in $PATH
6949 do
6950   IFS=$as_save_IFS
6951   test -z "$as_dir" && as_dir=.
6952     for ac_exec_ext in '' $ac_executable_extensions; do
6953   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6954     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6955     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6956     break 2
6957   fi
6958 done
6959   done
6960 IFS=$as_save_IFS
6961 
6962   ;;
6963 esac
6964 fi
6965 DIFF=$ac_cv_path_DIFF
6966 if test -n "$DIFF"; then
6967   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6968 $as_echo "$DIFF" >&6; }
6969 else
6970   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6971 $as_echo "no" >&6; }
6972 fi
6973 
6974 
6975   test -n "$DIFF" && break
6976 done
6977 
6978   else
6979     # The variable is set, but is it from the command line or the environment?
6980 
6981     # Try to remove the string !DIFF! from our list.
6982     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6983     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6984       # If it failed, the variable was not from the command line. Ignore it,
6985       # but warn the user (except for BASH, which is always set by the calling BASH).
6986       if test "xDIFF" != xBASH; then
6987         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6988 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6989       fi
6990       # Try to locate tool using the code snippet
6991       for ac_prog in gdiff diff
6992 do
6993   # Extract the first word of "$ac_prog", so it can be a program name with args.
6994 set dummy $ac_prog; ac_word=$2
6995 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6996 $as_echo_n "checking for $ac_word... " >&6; }
6997 if ${ac_cv_path_DIFF+:} false; then :
6998   $as_echo_n "(cached) " >&6
6999 else
7000   case $DIFF in
7001   [\\/]* | ?:[\\/]*)
7002   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7003   ;;
7004   *)
7005   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7006 for as_dir in $PATH
7007 do
7008   IFS=$as_save_IFS
7009   test -z "$as_dir" && as_dir=.
7010     for ac_exec_ext in '' $ac_executable_extensions; do
7011   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7012     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7013     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7014     break 2
7015   fi
7016 done
7017   done
7018 IFS=$as_save_IFS
7019 
7020   ;;
7021 esac
7022 fi
7023 DIFF=$ac_cv_path_DIFF
7024 if test -n "$DIFF"; then
7025   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7026 $as_echo "$DIFF" >&6; }
7027 else
7028   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7029 $as_echo "no" >&6; }
7030 fi
7031 
7032 
7033   test -n "$DIFF" && break
7034 done
7035 
7036     else
7037       # If it succeeded, then it was overridden by the user. We will use it
7038       # for the tool.
7039 
7040       # First remove it from the list of overridden variables, so we can test
7041       # for unknown variables in the end.
7042       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7043 
7044       # Check if we try to supply an empty value
7045       if test "x$DIFF" = x; then
7046         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
7047 $as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
7048         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7049 $as_echo_n "checking for DIFF... " >&6; }
7050         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7051 $as_echo "disabled" >&6; }
7052       else
7053         # Check if the provided tool contains a complete path.
7054         tool_specified="$DIFF"
7055         tool_basename="${tool_specified##*/}"
7056         if test "x$tool_basename" = "x$tool_specified"; then
7057           # A command without a complete path is provided, search $PATH.
7058           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
7059 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
7060           # Extract the first word of "$tool_basename", so it can be a program name with args.
7061 set dummy $tool_basename; ac_word=$2
7062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7063 $as_echo_n "checking for $ac_word... " >&6; }
7064 if ${ac_cv_path_DIFF+:} false; then :
7065   $as_echo_n "(cached) " >&6
7066 else
7067   case $DIFF in
7068   [\\/]* | ?:[\\/]*)
7069   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
7070   ;;
7071   *)
7072   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7073 for as_dir in $PATH
7074 do
7075   IFS=$as_save_IFS
7076   test -z "$as_dir" && as_dir=.
7077     for ac_exec_ext in '' $ac_executable_extensions; do
7078   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7079     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
7080     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7081     break 2
7082   fi
7083 done
7084   done
7085 IFS=$as_save_IFS
7086 
7087   ;;
7088 esac
7089 fi
7090 DIFF=$ac_cv_path_DIFF
7091 if test -n "$DIFF"; then
7092   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
7093 $as_echo "$DIFF" >&6; }
7094 else
7095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7096 $as_echo "no" >&6; }
7097 fi
7098 
7099 
7100           if test "x$DIFF" = x; then
7101             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7102           fi
7103         else
7104           # Otherwise we believe it is a complete path. Use it as it is.
7105           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
7106 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
7107           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
7108 $as_echo_n "checking for DIFF... " >&6; }
7109           if test ! -x "$tool_specified"; then
7110             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7111 $as_echo "not found" >&6; }
7112             as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
7113           fi
7114           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7115 $as_echo "$tool_specified" >&6; }
7116         fi
7117       fi
7118     fi
7119 
7120   fi
7121 
7122 
7123 
7124   if test "x$DIFF" = x; then
7125     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
7126   fi
7127 
7128 
7129 
7130 
7131 
7132   # Publish this variable in the help.
7133 
7134 
7135   if [ -z "${DIRNAME+x}" ]; then
7136     # The variable is not set by user, try to locate tool using the code snippet
7137     for ac_prog in dirname
7138 do
7139   # Extract the first word of "$ac_prog", so it can be a program name with args.
7140 set dummy $ac_prog; ac_word=$2
7141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7142 $as_echo_n "checking for $ac_word... " >&6; }
7143 if ${ac_cv_path_DIRNAME+:} false; then :
7144   $as_echo_n "(cached) " >&6
7145 else
7146   case $DIRNAME in
7147   [\\/]* | ?:[\\/]*)
7148   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7149   ;;
7150   *)
7151   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7152 for as_dir in $PATH
7153 do
7154   IFS=$as_save_IFS
7155   test -z "$as_dir" && as_dir=.
7156     for ac_exec_ext in '' $ac_executable_extensions; do
7157   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7158     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7159     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7160     break 2
7161   fi
7162 done
7163   done
7164 IFS=$as_save_IFS
7165 
7166   ;;
7167 esac
7168 fi
7169 DIRNAME=$ac_cv_path_DIRNAME
7170 if test -n "$DIRNAME"; then
7171   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7172 $as_echo "$DIRNAME" >&6; }
7173 else
7174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7175 $as_echo "no" >&6; }
7176 fi
7177 
7178 
7179   test -n "$DIRNAME" && break
7180 done
7181 
7182   else
7183     # The variable is set, but is it from the command line or the environment?
7184 
7185     # Try to remove the string !DIRNAME! from our list.
7186     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
7187     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7188       # If it failed, the variable was not from the command line. Ignore it,
7189       # but warn the user (except for BASH, which is always set by the calling BASH).
7190       if test "xDIRNAME" != xBASH; then
7191         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
7192 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
7193       fi
7194       # Try to locate tool using the code snippet
7195       for ac_prog in dirname
7196 do
7197   # Extract the first word of "$ac_prog", so it can be a program name with args.
7198 set dummy $ac_prog; ac_word=$2
7199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7200 $as_echo_n "checking for $ac_word... " >&6; }
7201 if ${ac_cv_path_DIRNAME+:} false; then :
7202   $as_echo_n "(cached) " >&6
7203 else
7204   case $DIRNAME in
7205   [\\/]* | ?:[\\/]*)
7206   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7207   ;;
7208   *)
7209   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7210 for as_dir in $PATH
7211 do
7212   IFS=$as_save_IFS
7213   test -z "$as_dir" && as_dir=.
7214     for ac_exec_ext in '' $ac_executable_extensions; do
7215   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7216     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7217     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7218     break 2
7219   fi
7220 done
7221   done
7222 IFS=$as_save_IFS
7223 
7224   ;;
7225 esac
7226 fi
7227 DIRNAME=$ac_cv_path_DIRNAME
7228 if test -n "$DIRNAME"; then
7229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7230 $as_echo "$DIRNAME" >&6; }
7231 else
7232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7233 $as_echo "no" >&6; }
7234 fi
7235 
7236 
7237   test -n "$DIRNAME" && break
7238 done
7239 
7240     else
7241       # If it succeeded, then it was overridden by the user. We will use it
7242       # for the tool.
7243 
7244       # First remove it from the list of overridden variables, so we can test
7245       # for unknown variables in the end.
7246       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7247 
7248       # Check if we try to supply an empty value
7249       if test "x$DIRNAME" = x; then
7250         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
7251 $as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
7252         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7253 $as_echo_n "checking for DIRNAME... " >&6; }
7254         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7255 $as_echo "disabled" >&6; }
7256       else
7257         # Check if the provided tool contains a complete path.
7258         tool_specified="$DIRNAME"
7259         tool_basename="${tool_specified##*/}"
7260         if test "x$tool_basename" = "x$tool_specified"; then
7261           # A command without a complete path is provided, search $PATH.
7262           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
7263 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
7264           # Extract the first word of "$tool_basename", so it can be a program name with args.
7265 set dummy $tool_basename; ac_word=$2
7266 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7267 $as_echo_n "checking for $ac_word... " >&6; }
7268 if ${ac_cv_path_DIRNAME+:} false; then :
7269   $as_echo_n "(cached) " >&6
7270 else
7271   case $DIRNAME in
7272   [\\/]* | ?:[\\/]*)
7273   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
7274   ;;
7275   *)
7276   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7277 for as_dir in $PATH
7278 do
7279   IFS=$as_save_IFS
7280   test -z "$as_dir" && as_dir=.
7281     for ac_exec_ext in '' $ac_executable_extensions; do
7282   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7283     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
7284     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7285     break 2
7286   fi
7287 done
7288   done
7289 IFS=$as_save_IFS
7290 
7291   ;;
7292 esac
7293 fi
7294 DIRNAME=$ac_cv_path_DIRNAME
7295 if test -n "$DIRNAME"; then
7296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
7297 $as_echo "$DIRNAME" >&6; }
7298 else
7299   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7300 $as_echo "no" >&6; }
7301 fi
7302 
7303 
7304           if test "x$DIRNAME" = x; then
7305             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7306           fi
7307         else
7308           # Otherwise we believe it is a complete path. Use it as it is.
7309           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
7310 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
7311           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
7312 $as_echo_n "checking for DIRNAME... " >&6; }
7313           if test ! -x "$tool_specified"; then
7314             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7315 $as_echo "not found" >&6; }
7316             as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
7317           fi
7318           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7319 $as_echo "$tool_specified" >&6; }
7320         fi
7321       fi
7322     fi
7323 
7324   fi
7325 
7326 
7327 
7328   if test "x$DIRNAME" = x; then
7329     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
7330   fi
7331 
7332 
7333 
7334 
7335 
7336   # Publish this variable in the help.
7337 
7338 
7339   if [ -z "${ECHO+x}" ]; then
7340     # The variable is not set by user, try to locate tool using the code snippet
7341     for ac_prog in echo
7342 do
7343   # Extract the first word of "$ac_prog", so it can be a program name with args.
7344 set dummy $ac_prog; ac_word=$2
7345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7346 $as_echo_n "checking for $ac_word... " >&6; }
7347 if ${ac_cv_path_ECHO+:} false; then :
7348   $as_echo_n "(cached) " >&6
7349 else
7350   case $ECHO in
7351   [\\/]* | ?:[\\/]*)
7352   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7353   ;;
7354   *)
7355   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7356 for as_dir in $PATH
7357 do
7358   IFS=$as_save_IFS
7359   test -z "$as_dir" && as_dir=.
7360     for ac_exec_ext in '' $ac_executable_extensions; do
7361   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7362     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7363     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7364     break 2
7365   fi
7366 done
7367   done
7368 IFS=$as_save_IFS
7369 
7370   ;;
7371 esac
7372 fi
7373 ECHO=$ac_cv_path_ECHO
7374 if test -n "$ECHO"; then
7375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7376 $as_echo "$ECHO" >&6; }
7377 else
7378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7379 $as_echo "no" >&6; }
7380 fi
7381 
7382 
7383   test -n "$ECHO" && break
7384 done
7385 
7386   else
7387     # The variable is set, but is it from the command line or the environment?
7388 
7389     # Try to remove the string !ECHO! from our list.
7390     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
7391     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7392       # If it failed, the variable was not from the command line. Ignore it,
7393       # but warn the user (except for BASH, which is always set by the calling BASH).
7394       if test "xECHO" != xBASH; then
7395         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
7396 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
7397       fi
7398       # Try to locate tool using the code snippet
7399       for ac_prog in echo
7400 do
7401   # Extract the first word of "$ac_prog", so it can be a program name with args.
7402 set dummy $ac_prog; ac_word=$2
7403 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7404 $as_echo_n "checking for $ac_word... " >&6; }
7405 if ${ac_cv_path_ECHO+:} false; then :
7406   $as_echo_n "(cached) " >&6
7407 else
7408   case $ECHO in
7409   [\\/]* | ?:[\\/]*)
7410   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7411   ;;
7412   *)
7413   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7414 for as_dir in $PATH
7415 do
7416   IFS=$as_save_IFS
7417   test -z "$as_dir" && as_dir=.
7418     for ac_exec_ext in '' $ac_executable_extensions; do
7419   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7420     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7421     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7422     break 2
7423   fi
7424 done
7425   done
7426 IFS=$as_save_IFS
7427 
7428   ;;
7429 esac
7430 fi
7431 ECHO=$ac_cv_path_ECHO
7432 if test -n "$ECHO"; then
7433   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7434 $as_echo "$ECHO" >&6; }
7435 else
7436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7437 $as_echo "no" >&6; }
7438 fi
7439 
7440 
7441   test -n "$ECHO" && break
7442 done
7443 
7444     else
7445       # If it succeeded, then it was overridden by the user. We will use it
7446       # for the tool.
7447 
7448       # First remove it from the list of overridden variables, so we can test
7449       # for unknown variables in the end.
7450       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7451 
7452       # Check if we try to supply an empty value
7453       if test "x$ECHO" = x; then
7454         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
7455 $as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
7456         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7457 $as_echo_n "checking for ECHO... " >&6; }
7458         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7459 $as_echo "disabled" >&6; }
7460       else
7461         # Check if the provided tool contains a complete path.
7462         tool_specified="$ECHO"
7463         tool_basename="${tool_specified##*/}"
7464         if test "x$tool_basename" = "x$tool_specified"; then
7465           # A command without a complete path is provided, search $PATH.
7466           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
7467 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
7468           # Extract the first word of "$tool_basename", so it can be a program name with args.
7469 set dummy $tool_basename; ac_word=$2
7470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7471 $as_echo_n "checking for $ac_word... " >&6; }
7472 if ${ac_cv_path_ECHO+:} false; then :
7473   $as_echo_n "(cached) " >&6
7474 else
7475   case $ECHO in
7476   [\\/]* | ?:[\\/]*)
7477   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
7478   ;;
7479   *)
7480   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7481 for as_dir in $PATH
7482 do
7483   IFS=$as_save_IFS
7484   test -z "$as_dir" && as_dir=.
7485     for ac_exec_ext in '' $ac_executable_extensions; do
7486   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7487     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
7488     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7489     break 2
7490   fi
7491 done
7492   done
7493 IFS=$as_save_IFS
7494 
7495   ;;
7496 esac
7497 fi
7498 ECHO=$ac_cv_path_ECHO
7499 if test -n "$ECHO"; then
7500   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
7501 $as_echo "$ECHO" >&6; }
7502 else
7503   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7504 $as_echo "no" >&6; }
7505 fi
7506 
7507 
7508           if test "x$ECHO" = x; then
7509             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7510           fi
7511         else
7512           # Otherwise we believe it is a complete path. Use it as it is.
7513           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
7514 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
7515           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
7516 $as_echo_n "checking for ECHO... " >&6; }
7517           if test ! -x "$tool_specified"; then
7518             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7519 $as_echo "not found" >&6; }
7520             as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
7521           fi
7522           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7523 $as_echo "$tool_specified" >&6; }
7524         fi
7525       fi
7526     fi
7527 
7528   fi
7529 
7530 
7531 
7532   if test "x$ECHO" = x; then
7533     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
7534   fi
7535 
7536 
7537 
7538 
7539 
7540   # Publish this variable in the help.
7541 
7542 
7543   if [ -z "${EXPR+x}" ]; then
7544     # The variable is not set by user, try to locate tool using the code snippet
7545     for ac_prog in expr
7546 do
7547   # Extract the first word of "$ac_prog", so it can be a program name with args.
7548 set dummy $ac_prog; ac_word=$2
7549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7550 $as_echo_n "checking for $ac_word... " >&6; }
7551 if ${ac_cv_path_EXPR+:} false; then :
7552   $as_echo_n "(cached) " >&6
7553 else
7554   case $EXPR in
7555   [\\/]* | ?:[\\/]*)
7556   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7557   ;;
7558   *)
7559   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7560 for as_dir in $PATH
7561 do
7562   IFS=$as_save_IFS
7563   test -z "$as_dir" && as_dir=.
7564     for ac_exec_ext in '' $ac_executable_extensions; do
7565   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7566     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7567     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7568     break 2
7569   fi
7570 done
7571   done
7572 IFS=$as_save_IFS
7573 
7574   ;;
7575 esac
7576 fi
7577 EXPR=$ac_cv_path_EXPR
7578 if test -n "$EXPR"; then
7579   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7580 $as_echo "$EXPR" >&6; }
7581 else
7582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7583 $as_echo "no" >&6; }
7584 fi
7585 
7586 
7587   test -n "$EXPR" && break
7588 done
7589 
7590   else
7591     # The variable is set, but is it from the command line or the environment?
7592 
7593     # Try to remove the string !EXPR! from our list.
7594     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
7595     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7596       # If it failed, the variable was not from the command line. Ignore it,
7597       # but warn the user (except for BASH, which is always set by the calling BASH).
7598       if test "xEXPR" != xBASH; then
7599         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
7600 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
7601       fi
7602       # Try to locate tool using the code snippet
7603       for ac_prog in expr
7604 do
7605   # Extract the first word of "$ac_prog", so it can be a program name with args.
7606 set dummy $ac_prog; ac_word=$2
7607 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7608 $as_echo_n "checking for $ac_word... " >&6; }
7609 if ${ac_cv_path_EXPR+:} false; then :
7610   $as_echo_n "(cached) " >&6
7611 else
7612   case $EXPR in
7613   [\\/]* | ?:[\\/]*)
7614   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7615   ;;
7616   *)
7617   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7618 for as_dir in $PATH
7619 do
7620   IFS=$as_save_IFS
7621   test -z "$as_dir" && as_dir=.
7622     for ac_exec_ext in '' $ac_executable_extensions; do
7623   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7624     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7625     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7626     break 2
7627   fi
7628 done
7629   done
7630 IFS=$as_save_IFS
7631 
7632   ;;
7633 esac
7634 fi
7635 EXPR=$ac_cv_path_EXPR
7636 if test -n "$EXPR"; then
7637   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7638 $as_echo "$EXPR" >&6; }
7639 else
7640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7641 $as_echo "no" >&6; }
7642 fi
7643 
7644 
7645   test -n "$EXPR" && break
7646 done
7647 
7648     else
7649       # If it succeeded, then it was overridden by the user. We will use it
7650       # for the tool.
7651 
7652       # First remove it from the list of overridden variables, so we can test
7653       # for unknown variables in the end.
7654       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7655 
7656       # Check if we try to supply an empty value
7657       if test "x$EXPR" = x; then
7658         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
7659 $as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
7660         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7661 $as_echo_n "checking for EXPR... " >&6; }
7662         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7663 $as_echo "disabled" >&6; }
7664       else
7665         # Check if the provided tool contains a complete path.
7666         tool_specified="$EXPR"
7667         tool_basename="${tool_specified##*/}"
7668         if test "x$tool_basename" = "x$tool_specified"; then
7669           # A command without a complete path is provided, search $PATH.
7670           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
7671 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
7672           # Extract the first word of "$tool_basename", so it can be a program name with args.
7673 set dummy $tool_basename; ac_word=$2
7674 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7675 $as_echo_n "checking for $ac_word... " >&6; }
7676 if ${ac_cv_path_EXPR+:} false; then :
7677   $as_echo_n "(cached) " >&6
7678 else
7679   case $EXPR in
7680   [\\/]* | ?:[\\/]*)
7681   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
7682   ;;
7683   *)
7684   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7685 for as_dir in $PATH
7686 do
7687   IFS=$as_save_IFS
7688   test -z "$as_dir" && as_dir=.
7689     for ac_exec_ext in '' $ac_executable_extensions; do
7690   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7691     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
7692     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7693     break 2
7694   fi
7695 done
7696   done
7697 IFS=$as_save_IFS
7698 
7699   ;;
7700 esac
7701 fi
7702 EXPR=$ac_cv_path_EXPR
7703 if test -n "$EXPR"; then
7704   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
7705 $as_echo "$EXPR" >&6; }
7706 else
7707   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7708 $as_echo "no" >&6; }
7709 fi
7710 
7711 
7712           if test "x$EXPR" = x; then
7713             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7714           fi
7715         else
7716           # Otherwise we believe it is a complete path. Use it as it is.
7717           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
7718 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
7719           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
7720 $as_echo_n "checking for EXPR... " >&6; }
7721           if test ! -x "$tool_specified"; then
7722             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7723 $as_echo "not found" >&6; }
7724             as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
7725           fi
7726           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7727 $as_echo "$tool_specified" >&6; }
7728         fi
7729       fi
7730     fi
7731 
7732   fi
7733 
7734 
7735 
7736   if test "x$EXPR" = x; then
7737     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7738   fi
7739 
7740 
7741 
7742 
7743 
7744   # Publish this variable in the help.
7745 
7746 
7747   if [ -z "${FILE+x}" ]; then
7748     # The variable is not set by user, try to locate tool using the code snippet
7749     for ac_prog in file
7750 do
7751   # Extract the first word of "$ac_prog", so it can be a program name with args.
7752 set dummy $ac_prog; ac_word=$2
7753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7754 $as_echo_n "checking for $ac_word... " >&6; }
7755 if ${ac_cv_path_FILE+:} false; then :
7756   $as_echo_n "(cached) " >&6
7757 else
7758   case $FILE in
7759   [\\/]* | ?:[\\/]*)
7760   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7761   ;;
7762   *)
7763   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7764 for as_dir in $PATH
7765 do
7766   IFS=$as_save_IFS
7767   test -z "$as_dir" && as_dir=.
7768     for ac_exec_ext in '' $ac_executable_extensions; do
7769   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7770     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7771     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7772     break 2
7773   fi
7774 done
7775   done
7776 IFS=$as_save_IFS
7777 
7778   ;;
7779 esac
7780 fi
7781 FILE=$ac_cv_path_FILE
7782 if test -n "$FILE"; then
7783   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7784 $as_echo "$FILE" >&6; }
7785 else
7786   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7787 $as_echo "no" >&6; }
7788 fi
7789 
7790 
7791   test -n "$FILE" && break
7792 done
7793 
7794   else
7795     # The variable is set, but is it from the command line or the environment?
7796 
7797     # Try to remove the string !FILE! from our list.
7798     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7799     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7800       # If it failed, the variable was not from the command line. Ignore it,
7801       # but warn the user (except for BASH, which is always set by the calling BASH).
7802       if test "xFILE" != xBASH; then
7803         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7804 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7805       fi
7806       # Try to locate tool using the code snippet
7807       for ac_prog in file
7808 do
7809   # Extract the first word of "$ac_prog", so it can be a program name with args.
7810 set dummy $ac_prog; ac_word=$2
7811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7812 $as_echo_n "checking for $ac_word... " >&6; }
7813 if ${ac_cv_path_FILE+:} false; then :
7814   $as_echo_n "(cached) " >&6
7815 else
7816   case $FILE in
7817   [\\/]* | ?:[\\/]*)
7818   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7819   ;;
7820   *)
7821   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7822 for as_dir in $PATH
7823 do
7824   IFS=$as_save_IFS
7825   test -z "$as_dir" && as_dir=.
7826     for ac_exec_ext in '' $ac_executable_extensions; do
7827   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7828     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7829     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7830     break 2
7831   fi
7832 done
7833   done
7834 IFS=$as_save_IFS
7835 
7836   ;;
7837 esac
7838 fi
7839 FILE=$ac_cv_path_FILE
7840 if test -n "$FILE"; then
7841   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7842 $as_echo "$FILE" >&6; }
7843 else
7844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7845 $as_echo "no" >&6; }
7846 fi
7847 
7848 
7849   test -n "$FILE" && break
7850 done
7851 
7852     else
7853       # If it succeeded, then it was overridden by the user. We will use it
7854       # for the tool.
7855 
7856       # First remove it from the list of overridden variables, so we can test
7857       # for unknown variables in the end.
7858       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7859 
7860       # Check if we try to supply an empty value
7861       if test "x$FILE" = x; then
7862         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
7863 $as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
7864         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7865 $as_echo_n "checking for FILE... " >&6; }
7866         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
7867 $as_echo "disabled" >&6; }
7868       else
7869         # Check if the provided tool contains a complete path.
7870         tool_specified="$FILE"
7871         tool_basename="${tool_specified##*/}"
7872         if test "x$tool_basename" = "x$tool_specified"; then
7873           # A command without a complete path is provided, search $PATH.
7874           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7875 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7876           # Extract the first word of "$tool_basename", so it can be a program name with args.
7877 set dummy $tool_basename; ac_word=$2
7878 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7879 $as_echo_n "checking for $ac_word... " >&6; }
7880 if ${ac_cv_path_FILE+:} false; then :
7881   $as_echo_n "(cached) " >&6
7882 else
7883   case $FILE in
7884   [\\/]* | ?:[\\/]*)
7885   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7886   ;;
7887   *)
7888   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7889 for as_dir in $PATH
7890 do
7891   IFS=$as_save_IFS
7892   test -z "$as_dir" && as_dir=.
7893     for ac_exec_ext in '' $ac_executable_extensions; do
7894   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7895     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7896     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7897     break 2
7898   fi
7899 done
7900   done
7901 IFS=$as_save_IFS
7902 
7903   ;;
7904 esac
7905 fi
7906 FILE=$ac_cv_path_FILE
7907 if test -n "$FILE"; then
7908   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7909 $as_echo "$FILE" >&6; }
7910 else
7911   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7912 $as_echo "no" >&6; }
7913 fi
7914 
7915 
7916           if test "x$FILE" = x; then
7917             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7918           fi
7919         else
7920           # Otherwise we believe it is a complete path. Use it as it is.
7921           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7922 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7923           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7924 $as_echo_n "checking for FILE... " >&6; }
7925           if test ! -x "$tool_specified"; then
7926             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7927 $as_echo "not found" >&6; }
7928             as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7929           fi
7930           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7931 $as_echo "$tool_specified" >&6; }
7932         fi
7933       fi
7934     fi
7935 
7936   fi
7937 
7938 
7939 
7940   if test "x$FILE" = x; then
7941     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7942   fi
7943 
7944 
7945 
7946 
7947 
7948   # Publish this variable in the help.
7949 
7950 
7951   if [ -z "${FIND+x}" ]; then
7952     # The variable is not set by user, try to locate tool using the code snippet
7953     for ac_prog in find
7954 do
7955   # Extract the first word of "$ac_prog", so it can be a program name with args.
7956 set dummy $ac_prog; ac_word=$2
7957 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7958 $as_echo_n "checking for $ac_word... " >&6; }
7959 if ${ac_cv_path_FIND+:} false; then :
7960   $as_echo_n "(cached) " >&6
7961 else
7962   case $FIND in
7963   [\\/]* | ?:[\\/]*)
7964   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7965   ;;
7966   *)
7967   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7968 for as_dir in $PATH
7969 do
7970   IFS=$as_save_IFS
7971   test -z "$as_dir" && as_dir=.
7972     for ac_exec_ext in '' $ac_executable_extensions; do
7973   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7974     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7975     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7976     break 2
7977   fi
7978 done
7979   done
7980 IFS=$as_save_IFS
7981 
7982   ;;
7983 esac
7984 fi
7985 FIND=$ac_cv_path_FIND
7986 if test -n "$FIND"; then
7987   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7988 $as_echo "$FIND" >&6; }
7989 else
7990   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7991 $as_echo "no" >&6; }
7992 fi
7993 
7994 
7995   test -n "$FIND" && break
7996 done
7997 
7998   else
7999     # The variable is set, but is it from the command line or the environment?
8000 
8001     # Try to remove the string !FIND! from our list.
8002     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
8003     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8004       # If it failed, the variable was not from the command line. Ignore it,
8005       # but warn the user (except for BASH, which is always set by the calling BASH).
8006       if test "xFIND" != xBASH; then
8007         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
8008 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
8009       fi
8010       # Try to locate tool using the code snippet
8011       for ac_prog in find
8012 do
8013   # Extract the first word of "$ac_prog", so it can be a program name with args.
8014 set dummy $ac_prog; ac_word=$2
8015 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8016 $as_echo_n "checking for $ac_word... " >&6; }
8017 if ${ac_cv_path_FIND+:} false; then :
8018   $as_echo_n "(cached) " >&6
8019 else
8020   case $FIND in
8021   [\\/]* | ?:[\\/]*)
8022   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8023   ;;
8024   *)
8025   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8026 for as_dir in $PATH
8027 do
8028   IFS=$as_save_IFS
8029   test -z "$as_dir" && as_dir=.
8030     for ac_exec_ext in '' $ac_executable_extensions; do
8031   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8032     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8033     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8034     break 2
8035   fi
8036 done
8037   done
8038 IFS=$as_save_IFS
8039 
8040   ;;
8041 esac
8042 fi
8043 FIND=$ac_cv_path_FIND
8044 if test -n "$FIND"; then
8045   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8046 $as_echo "$FIND" >&6; }
8047 else
8048   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8049 $as_echo "no" >&6; }
8050 fi
8051 
8052 
8053   test -n "$FIND" && break
8054 done
8055 
8056     else
8057       # If it succeeded, then it was overridden by the user. We will use it
8058       # for the tool.
8059 
8060       # First remove it from the list of overridden variables, so we can test
8061       # for unknown variables in the end.
8062       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8063 
8064       # Check if we try to supply an empty value
8065       if test "x$FIND" = x; then
8066         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
8067 $as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
8068         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8069 $as_echo_n "checking for FIND... " >&6; }
8070         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8071 $as_echo "disabled" >&6; }
8072       else
8073         # Check if the provided tool contains a complete path.
8074         tool_specified="$FIND"
8075         tool_basename="${tool_specified##*/}"
8076         if test "x$tool_basename" = "x$tool_specified"; then
8077           # A command without a complete path is provided, search $PATH.
8078           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
8079 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
8080           # Extract the first word of "$tool_basename", so it can be a program name with args.
8081 set dummy $tool_basename; ac_word=$2
8082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8083 $as_echo_n "checking for $ac_word... " >&6; }
8084 if ${ac_cv_path_FIND+:} false; then :
8085   $as_echo_n "(cached) " >&6
8086 else
8087   case $FIND in
8088   [\\/]* | ?:[\\/]*)
8089   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
8090   ;;
8091   *)
8092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8093 for as_dir in $PATH
8094 do
8095   IFS=$as_save_IFS
8096   test -z "$as_dir" && as_dir=.
8097     for ac_exec_ext in '' $ac_executable_extensions; do
8098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8099     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
8100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8101     break 2
8102   fi
8103 done
8104   done
8105 IFS=$as_save_IFS
8106 
8107   ;;
8108 esac
8109 fi
8110 FIND=$ac_cv_path_FIND
8111 if test -n "$FIND"; then
8112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
8113 $as_echo "$FIND" >&6; }
8114 else
8115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8116 $as_echo "no" >&6; }
8117 fi
8118 
8119 
8120           if test "x$FIND" = x; then
8121             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8122           fi
8123         else
8124           # Otherwise we believe it is a complete path. Use it as it is.
8125           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
8126 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
8127           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
8128 $as_echo_n "checking for FIND... " >&6; }
8129           if test ! -x "$tool_specified"; then
8130             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8131 $as_echo "not found" >&6; }
8132             as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
8133           fi
8134           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8135 $as_echo "$tool_specified" >&6; }
8136         fi
8137       fi
8138     fi
8139 
8140   fi
8141 
8142 
8143 
8144   if test "x$FIND" = x; then
8145     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
8146   fi
8147 
8148 
8149 
8150 
8151 
8152   # Publish this variable in the help.
8153 
8154 
8155   if [ -z "${HEAD+x}" ]; then
8156     # The variable is not set by user, try to locate tool using the code snippet
8157     for ac_prog in head
8158 do
8159   # Extract the first word of "$ac_prog", so it can be a program name with args.
8160 set dummy $ac_prog; ac_word=$2
8161 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8162 $as_echo_n "checking for $ac_word... " >&6; }
8163 if ${ac_cv_path_HEAD+:} false; then :
8164   $as_echo_n "(cached) " >&6
8165 else
8166   case $HEAD in
8167   [\\/]* | ?:[\\/]*)
8168   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8169   ;;
8170   *)
8171   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8172 for as_dir in $PATH
8173 do
8174   IFS=$as_save_IFS
8175   test -z "$as_dir" && as_dir=.
8176     for ac_exec_ext in '' $ac_executable_extensions; do
8177   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8178     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8179     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8180     break 2
8181   fi
8182 done
8183   done
8184 IFS=$as_save_IFS
8185 
8186   ;;
8187 esac
8188 fi
8189 HEAD=$ac_cv_path_HEAD
8190 if test -n "$HEAD"; then
8191   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8192 $as_echo "$HEAD" >&6; }
8193 else
8194   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8195 $as_echo "no" >&6; }
8196 fi
8197 
8198 
8199   test -n "$HEAD" && break
8200 done
8201 
8202   else
8203     # The variable is set, but is it from the command line or the environment?
8204 
8205     # Try to remove the string !HEAD! from our list.
8206     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
8207     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8208       # If it failed, the variable was not from the command line. Ignore it,
8209       # but warn the user (except for BASH, which is always set by the calling BASH).
8210       if test "xHEAD" != xBASH; then
8211         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
8212 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
8213       fi
8214       # Try to locate tool using the code snippet
8215       for ac_prog in head
8216 do
8217   # Extract the first word of "$ac_prog", so it can be a program name with args.
8218 set dummy $ac_prog; ac_word=$2
8219 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8220 $as_echo_n "checking for $ac_word... " >&6; }
8221 if ${ac_cv_path_HEAD+:} false; then :
8222   $as_echo_n "(cached) " >&6
8223 else
8224   case $HEAD in
8225   [\\/]* | ?:[\\/]*)
8226   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8227   ;;
8228   *)
8229   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8230 for as_dir in $PATH
8231 do
8232   IFS=$as_save_IFS
8233   test -z "$as_dir" && as_dir=.
8234     for ac_exec_ext in '' $ac_executable_extensions; do
8235   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8236     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8237     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8238     break 2
8239   fi
8240 done
8241   done
8242 IFS=$as_save_IFS
8243 
8244   ;;
8245 esac
8246 fi
8247 HEAD=$ac_cv_path_HEAD
8248 if test -n "$HEAD"; then
8249   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8250 $as_echo "$HEAD" >&6; }
8251 else
8252   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8253 $as_echo "no" >&6; }
8254 fi
8255 
8256 
8257   test -n "$HEAD" && break
8258 done
8259 
8260     else
8261       # If it succeeded, then it was overridden by the user. We will use it
8262       # for the tool.
8263 
8264       # First remove it from the list of overridden variables, so we can test
8265       # for unknown variables in the end.
8266       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8267 
8268       # Check if we try to supply an empty value
8269       if test "x$HEAD" = x; then
8270         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
8271 $as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
8272         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8273 $as_echo_n "checking for HEAD... " >&6; }
8274         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8275 $as_echo "disabled" >&6; }
8276       else
8277         # Check if the provided tool contains a complete path.
8278         tool_specified="$HEAD"
8279         tool_basename="${tool_specified##*/}"
8280         if test "x$tool_basename" = "x$tool_specified"; then
8281           # A command without a complete path is provided, search $PATH.
8282           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
8283 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
8284           # Extract the first word of "$tool_basename", so it can be a program name with args.
8285 set dummy $tool_basename; ac_word=$2
8286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8287 $as_echo_n "checking for $ac_word... " >&6; }
8288 if ${ac_cv_path_HEAD+:} false; then :
8289   $as_echo_n "(cached) " >&6
8290 else
8291   case $HEAD in
8292   [\\/]* | ?:[\\/]*)
8293   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
8294   ;;
8295   *)
8296   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8297 for as_dir in $PATH
8298 do
8299   IFS=$as_save_IFS
8300   test -z "$as_dir" && as_dir=.
8301     for ac_exec_ext in '' $ac_executable_extensions; do
8302   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8303     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
8304     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8305     break 2
8306   fi
8307 done
8308   done
8309 IFS=$as_save_IFS
8310 
8311   ;;
8312 esac
8313 fi
8314 HEAD=$ac_cv_path_HEAD
8315 if test -n "$HEAD"; then
8316   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
8317 $as_echo "$HEAD" >&6; }
8318 else
8319   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8320 $as_echo "no" >&6; }
8321 fi
8322 
8323 
8324           if test "x$HEAD" = x; then
8325             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8326           fi
8327         else
8328           # Otherwise we believe it is a complete path. Use it as it is.
8329           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
8330 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
8331           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
8332 $as_echo_n "checking for HEAD... " >&6; }
8333           if test ! -x "$tool_specified"; then
8334             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8335 $as_echo "not found" >&6; }
8336             as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
8337           fi
8338           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8339 $as_echo "$tool_specified" >&6; }
8340         fi
8341       fi
8342     fi
8343 
8344   fi
8345 
8346 
8347 
8348   if test "x$HEAD" = x; then
8349     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
8350   fi
8351 
8352 
8353 
8354 
8355 
8356   # Publish this variable in the help.
8357 
8358 
8359   if [ -z "${LN+x}" ]; then
8360     # The variable is not set by user, try to locate tool using the code snippet
8361     for ac_prog in ln
8362 do
8363   # Extract the first word of "$ac_prog", so it can be a program name with args.
8364 set dummy $ac_prog; ac_word=$2
8365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8366 $as_echo_n "checking for $ac_word... " >&6; }
8367 if ${ac_cv_path_LN+:} false; then :
8368   $as_echo_n "(cached) " >&6
8369 else
8370   case $LN in
8371   [\\/]* | ?:[\\/]*)
8372   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8373   ;;
8374   *)
8375   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8376 for as_dir in $PATH
8377 do
8378   IFS=$as_save_IFS
8379   test -z "$as_dir" && as_dir=.
8380     for ac_exec_ext in '' $ac_executable_extensions; do
8381   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8382     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8383     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8384     break 2
8385   fi
8386 done
8387   done
8388 IFS=$as_save_IFS
8389 
8390   ;;
8391 esac
8392 fi
8393 LN=$ac_cv_path_LN
8394 if test -n "$LN"; then
8395   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8396 $as_echo "$LN" >&6; }
8397 else
8398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8399 $as_echo "no" >&6; }
8400 fi
8401 
8402 
8403   test -n "$LN" && break
8404 done
8405 
8406   else
8407     # The variable is set, but is it from the command line or the environment?
8408 
8409     # Try to remove the string !LN! from our list.
8410     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
8411     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8412       # If it failed, the variable was not from the command line. Ignore it,
8413       # but warn the user (except for BASH, which is always set by the calling BASH).
8414       if test "xLN" != xBASH; then
8415         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
8416 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
8417       fi
8418       # Try to locate tool using the code snippet
8419       for ac_prog in ln
8420 do
8421   # Extract the first word of "$ac_prog", so it can be a program name with args.
8422 set dummy $ac_prog; ac_word=$2
8423 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8424 $as_echo_n "checking for $ac_word... " >&6; }
8425 if ${ac_cv_path_LN+:} false; then :
8426   $as_echo_n "(cached) " >&6
8427 else
8428   case $LN in
8429   [\\/]* | ?:[\\/]*)
8430   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8431   ;;
8432   *)
8433   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8434 for as_dir in $PATH
8435 do
8436   IFS=$as_save_IFS
8437   test -z "$as_dir" && as_dir=.
8438     for ac_exec_ext in '' $ac_executable_extensions; do
8439   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8440     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8441     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8442     break 2
8443   fi
8444 done
8445   done
8446 IFS=$as_save_IFS
8447 
8448   ;;
8449 esac
8450 fi
8451 LN=$ac_cv_path_LN
8452 if test -n "$LN"; then
8453   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8454 $as_echo "$LN" >&6; }
8455 else
8456   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8457 $as_echo "no" >&6; }
8458 fi
8459 
8460 
8461   test -n "$LN" && break
8462 done
8463 
8464     else
8465       # If it succeeded, then it was overridden by the user. We will use it
8466       # for the tool.
8467 
8468       # First remove it from the list of overridden variables, so we can test
8469       # for unknown variables in the end.
8470       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8471 
8472       # Check if we try to supply an empty value
8473       if test "x$LN" = x; then
8474         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
8475 $as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
8476         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8477 $as_echo_n "checking for LN... " >&6; }
8478         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8479 $as_echo "disabled" >&6; }
8480       else
8481         # Check if the provided tool contains a complete path.
8482         tool_specified="$LN"
8483         tool_basename="${tool_specified##*/}"
8484         if test "x$tool_basename" = "x$tool_specified"; then
8485           # A command without a complete path is provided, search $PATH.
8486           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
8487 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
8488           # Extract the first word of "$tool_basename", so it can be a program name with args.
8489 set dummy $tool_basename; ac_word=$2
8490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8491 $as_echo_n "checking for $ac_word... " >&6; }
8492 if ${ac_cv_path_LN+:} false; then :
8493   $as_echo_n "(cached) " >&6
8494 else
8495   case $LN in
8496   [\\/]* | ?:[\\/]*)
8497   ac_cv_path_LN="$LN" # Let the user override the test with a path.
8498   ;;
8499   *)
8500   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8501 for as_dir in $PATH
8502 do
8503   IFS=$as_save_IFS
8504   test -z "$as_dir" && as_dir=.
8505     for ac_exec_ext in '' $ac_executable_extensions; do
8506   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8507     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
8508     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8509     break 2
8510   fi
8511 done
8512   done
8513 IFS=$as_save_IFS
8514 
8515   ;;
8516 esac
8517 fi
8518 LN=$ac_cv_path_LN
8519 if test -n "$LN"; then
8520   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
8521 $as_echo "$LN" >&6; }
8522 else
8523   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8524 $as_echo "no" >&6; }
8525 fi
8526 
8527 
8528           if test "x$LN" = x; then
8529             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8530           fi
8531         else
8532           # Otherwise we believe it is a complete path. Use it as it is.
8533           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
8534 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
8535           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
8536 $as_echo_n "checking for LN... " >&6; }
8537           if test ! -x "$tool_specified"; then
8538             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8539 $as_echo "not found" >&6; }
8540             as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
8541           fi
8542           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8543 $as_echo "$tool_specified" >&6; }
8544         fi
8545       fi
8546     fi
8547 
8548   fi
8549 
8550 
8551 
8552   if test "x$LN" = x; then
8553     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
8554   fi
8555 
8556 
8557 
8558 
8559 
8560   # Publish this variable in the help.
8561 
8562 
8563   if [ -z "${LS+x}" ]; then
8564     # The variable is not set by user, try to locate tool using the code snippet
8565     for ac_prog in ls
8566 do
8567   # Extract the first word of "$ac_prog", so it can be a program name with args.
8568 set dummy $ac_prog; ac_word=$2
8569 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8570 $as_echo_n "checking for $ac_word... " >&6; }
8571 if ${ac_cv_path_LS+:} false; then :
8572   $as_echo_n "(cached) " >&6
8573 else
8574   case $LS in
8575   [\\/]* | ?:[\\/]*)
8576   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8577   ;;
8578   *)
8579   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8580 for as_dir in $PATH
8581 do
8582   IFS=$as_save_IFS
8583   test -z "$as_dir" && as_dir=.
8584     for ac_exec_ext in '' $ac_executable_extensions; do
8585   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8586     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8587     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8588     break 2
8589   fi
8590 done
8591   done
8592 IFS=$as_save_IFS
8593 
8594   ;;
8595 esac
8596 fi
8597 LS=$ac_cv_path_LS
8598 if test -n "$LS"; then
8599   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8600 $as_echo "$LS" >&6; }
8601 else
8602   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8603 $as_echo "no" >&6; }
8604 fi
8605 
8606 
8607   test -n "$LS" && break
8608 done
8609 
8610   else
8611     # The variable is set, but is it from the command line or the environment?
8612 
8613     # Try to remove the string !LS! from our list.
8614     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
8615     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8616       # If it failed, the variable was not from the command line. Ignore it,
8617       # but warn the user (except for BASH, which is always set by the calling BASH).
8618       if test "xLS" != xBASH; then
8619         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
8620 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
8621       fi
8622       # Try to locate tool using the code snippet
8623       for ac_prog in ls
8624 do
8625   # Extract the first word of "$ac_prog", so it can be a program name with args.
8626 set dummy $ac_prog; ac_word=$2
8627 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8628 $as_echo_n "checking for $ac_word... " >&6; }
8629 if ${ac_cv_path_LS+:} false; then :
8630   $as_echo_n "(cached) " >&6
8631 else
8632   case $LS in
8633   [\\/]* | ?:[\\/]*)
8634   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8635   ;;
8636   *)
8637   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8638 for as_dir in $PATH
8639 do
8640   IFS=$as_save_IFS
8641   test -z "$as_dir" && as_dir=.
8642     for ac_exec_ext in '' $ac_executable_extensions; do
8643   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8644     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8645     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8646     break 2
8647   fi
8648 done
8649   done
8650 IFS=$as_save_IFS
8651 
8652   ;;
8653 esac
8654 fi
8655 LS=$ac_cv_path_LS
8656 if test -n "$LS"; then
8657   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8658 $as_echo "$LS" >&6; }
8659 else
8660   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8661 $as_echo "no" >&6; }
8662 fi
8663 
8664 
8665   test -n "$LS" && break
8666 done
8667 
8668     else
8669       # If it succeeded, then it was overridden by the user. We will use it
8670       # for the tool.
8671 
8672       # First remove it from the list of overridden variables, so we can test
8673       # for unknown variables in the end.
8674       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8675 
8676       # Check if we try to supply an empty value
8677       if test "x$LS" = x; then
8678         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
8679 $as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
8680         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8681 $as_echo_n "checking for LS... " >&6; }
8682         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8683 $as_echo "disabled" >&6; }
8684       else
8685         # Check if the provided tool contains a complete path.
8686         tool_specified="$LS"
8687         tool_basename="${tool_specified##*/}"
8688         if test "x$tool_basename" = "x$tool_specified"; then
8689           # A command without a complete path is provided, search $PATH.
8690           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
8691 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
8692           # Extract the first word of "$tool_basename", so it can be a program name with args.
8693 set dummy $tool_basename; ac_word=$2
8694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8695 $as_echo_n "checking for $ac_word... " >&6; }
8696 if ${ac_cv_path_LS+:} false; then :
8697   $as_echo_n "(cached) " >&6
8698 else
8699   case $LS in
8700   [\\/]* | ?:[\\/]*)
8701   ac_cv_path_LS="$LS" # Let the user override the test with a path.
8702   ;;
8703   *)
8704   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8705 for as_dir in $PATH
8706 do
8707   IFS=$as_save_IFS
8708   test -z "$as_dir" && as_dir=.
8709     for ac_exec_ext in '' $ac_executable_extensions; do
8710   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8711     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
8712     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8713     break 2
8714   fi
8715 done
8716   done
8717 IFS=$as_save_IFS
8718 
8719   ;;
8720 esac
8721 fi
8722 LS=$ac_cv_path_LS
8723 if test -n "$LS"; then
8724   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
8725 $as_echo "$LS" >&6; }
8726 else
8727   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8728 $as_echo "no" >&6; }
8729 fi
8730 
8731 
8732           if test "x$LS" = x; then
8733             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8734           fi
8735         else
8736           # Otherwise we believe it is a complete path. Use it as it is.
8737           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
8738 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
8739           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
8740 $as_echo_n "checking for LS... " >&6; }
8741           if test ! -x "$tool_specified"; then
8742             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8743 $as_echo "not found" >&6; }
8744             as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
8745           fi
8746           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8747 $as_echo "$tool_specified" >&6; }
8748         fi
8749       fi
8750     fi
8751 
8752   fi
8753 
8754 
8755 
8756   if test "x$LS" = x; then
8757     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
8758   fi
8759 
8760 
8761 
8762 
8763 
8764   # Publish this variable in the help.
8765 
8766 
8767   if [ -z "${MKDIR+x}" ]; then
8768     # The variable is not set by user, try to locate tool using the code snippet
8769     for ac_prog in mkdir
8770 do
8771   # Extract the first word of "$ac_prog", so it can be a program name with args.
8772 set dummy $ac_prog; ac_word=$2
8773 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8774 $as_echo_n "checking for $ac_word... " >&6; }
8775 if ${ac_cv_path_MKDIR+:} false; then :
8776   $as_echo_n "(cached) " >&6
8777 else
8778   case $MKDIR in
8779   [\\/]* | ?:[\\/]*)
8780   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8781   ;;
8782   *)
8783   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8784 for as_dir in $PATH
8785 do
8786   IFS=$as_save_IFS
8787   test -z "$as_dir" && as_dir=.
8788     for ac_exec_ext in '' $ac_executable_extensions; do
8789   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8790     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8791     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8792     break 2
8793   fi
8794 done
8795   done
8796 IFS=$as_save_IFS
8797 
8798   ;;
8799 esac
8800 fi
8801 MKDIR=$ac_cv_path_MKDIR
8802 if test -n "$MKDIR"; then
8803   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8804 $as_echo "$MKDIR" >&6; }
8805 else
8806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8807 $as_echo "no" >&6; }
8808 fi
8809 
8810 
8811   test -n "$MKDIR" && break
8812 done
8813 
8814   else
8815     # The variable is set, but is it from the command line or the environment?
8816 
8817     # Try to remove the string !MKDIR! from our list.
8818     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8819     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8820       # If it failed, the variable was not from the command line. Ignore it,
8821       # but warn the user (except for BASH, which is always set by the calling BASH).
8822       if test "xMKDIR" != xBASH; then
8823         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8824 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8825       fi
8826       # Try to locate tool using the code snippet
8827       for ac_prog in mkdir
8828 do
8829   # Extract the first word of "$ac_prog", so it can be a program name with args.
8830 set dummy $ac_prog; ac_word=$2
8831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8832 $as_echo_n "checking for $ac_word... " >&6; }
8833 if ${ac_cv_path_MKDIR+:} false; then :
8834   $as_echo_n "(cached) " >&6
8835 else
8836   case $MKDIR in
8837   [\\/]* | ?:[\\/]*)
8838   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8839   ;;
8840   *)
8841   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8842 for as_dir in $PATH
8843 do
8844   IFS=$as_save_IFS
8845   test -z "$as_dir" && as_dir=.
8846     for ac_exec_ext in '' $ac_executable_extensions; do
8847   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8848     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8849     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8850     break 2
8851   fi
8852 done
8853   done
8854 IFS=$as_save_IFS
8855 
8856   ;;
8857 esac
8858 fi
8859 MKDIR=$ac_cv_path_MKDIR
8860 if test -n "$MKDIR"; then
8861   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8862 $as_echo "$MKDIR" >&6; }
8863 else
8864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8865 $as_echo "no" >&6; }
8866 fi
8867 
8868 
8869   test -n "$MKDIR" && break
8870 done
8871 
8872     else
8873       # If it succeeded, then it was overridden by the user. We will use it
8874       # for the tool.
8875 
8876       # First remove it from the list of overridden variables, so we can test
8877       # for unknown variables in the end.
8878       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8879 
8880       # Check if we try to supply an empty value
8881       if test "x$MKDIR" = x; then
8882         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
8883 $as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
8884         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8885 $as_echo_n "checking for MKDIR... " >&6; }
8886         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
8887 $as_echo "disabled" >&6; }
8888       else
8889         # Check if the provided tool contains a complete path.
8890         tool_specified="$MKDIR"
8891         tool_basename="${tool_specified##*/}"
8892         if test "x$tool_basename" = "x$tool_specified"; then
8893           # A command without a complete path is provided, search $PATH.
8894           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8895 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8896           # Extract the first word of "$tool_basename", so it can be a program name with args.
8897 set dummy $tool_basename; ac_word=$2
8898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8899 $as_echo_n "checking for $ac_word... " >&6; }
8900 if ${ac_cv_path_MKDIR+:} false; then :
8901   $as_echo_n "(cached) " >&6
8902 else
8903   case $MKDIR in
8904   [\\/]* | ?:[\\/]*)
8905   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8906   ;;
8907   *)
8908   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8909 for as_dir in $PATH
8910 do
8911   IFS=$as_save_IFS
8912   test -z "$as_dir" && as_dir=.
8913     for ac_exec_ext in '' $ac_executable_extensions; do
8914   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8915     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8916     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8917     break 2
8918   fi
8919 done
8920   done
8921 IFS=$as_save_IFS
8922 
8923   ;;
8924 esac
8925 fi
8926 MKDIR=$ac_cv_path_MKDIR
8927 if test -n "$MKDIR"; then
8928   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8929 $as_echo "$MKDIR" >&6; }
8930 else
8931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8932 $as_echo "no" >&6; }
8933 fi
8934 
8935 
8936           if test "x$MKDIR" = x; then
8937             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8938           fi
8939         else
8940           # Otherwise we believe it is a complete path. Use it as it is.
8941           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8942 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8943           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8944 $as_echo_n "checking for MKDIR... " >&6; }
8945           if test ! -x "$tool_specified"; then
8946             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8947 $as_echo "not found" >&6; }
8948             as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8949           fi
8950           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8951 $as_echo "$tool_specified" >&6; }
8952         fi
8953       fi
8954     fi
8955 
8956   fi
8957 
8958 
8959 
8960   if test "x$MKDIR" = x; then
8961     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8962   fi
8963 
8964 
8965 
8966 
8967 
8968   # Publish this variable in the help.
8969 
8970 
8971   if [ -z "${MKTEMP+x}" ]; then
8972     # The variable is not set by user, try to locate tool using the code snippet
8973     for ac_prog in mktemp
8974 do
8975   # Extract the first word of "$ac_prog", so it can be a program name with args.
8976 set dummy $ac_prog; ac_word=$2
8977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8978 $as_echo_n "checking for $ac_word... " >&6; }
8979 if ${ac_cv_path_MKTEMP+:} false; then :
8980   $as_echo_n "(cached) " >&6
8981 else
8982   case $MKTEMP in
8983   [\\/]* | ?:[\\/]*)
8984   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8985   ;;
8986   *)
8987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8988 for as_dir in $PATH
8989 do
8990   IFS=$as_save_IFS
8991   test -z "$as_dir" && as_dir=.
8992     for ac_exec_ext in '' $ac_executable_extensions; do
8993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8994     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8996     break 2
8997   fi
8998 done
8999   done
9000 IFS=$as_save_IFS
9001 
9002   ;;
9003 esac
9004 fi
9005 MKTEMP=$ac_cv_path_MKTEMP
9006 if test -n "$MKTEMP"; then
9007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9008 $as_echo "$MKTEMP" >&6; }
9009 else
9010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9011 $as_echo "no" >&6; }
9012 fi
9013 
9014 
9015   test -n "$MKTEMP" && break
9016 done
9017 
9018   else
9019     # The variable is set, but is it from the command line or the environment?
9020 
9021     # Try to remove the string !MKTEMP! from our list.
9022     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
9023     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9024       # If it failed, the variable was not from the command line. Ignore it,
9025       # but warn the user (except for BASH, which is always set by the calling BASH).
9026       if test "xMKTEMP" != xBASH; then
9027         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
9028 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
9029       fi
9030       # Try to locate tool using the code snippet
9031       for ac_prog in mktemp
9032 do
9033   # Extract the first word of "$ac_prog", so it can be a program name with args.
9034 set dummy $ac_prog; ac_word=$2
9035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9036 $as_echo_n "checking for $ac_word... " >&6; }
9037 if ${ac_cv_path_MKTEMP+:} false; then :
9038   $as_echo_n "(cached) " >&6
9039 else
9040   case $MKTEMP in
9041   [\\/]* | ?:[\\/]*)
9042   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9043   ;;
9044   *)
9045   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9046 for as_dir in $PATH
9047 do
9048   IFS=$as_save_IFS
9049   test -z "$as_dir" && as_dir=.
9050     for ac_exec_ext in '' $ac_executable_extensions; do
9051   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9052     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9053     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9054     break 2
9055   fi
9056 done
9057   done
9058 IFS=$as_save_IFS
9059 
9060   ;;
9061 esac
9062 fi
9063 MKTEMP=$ac_cv_path_MKTEMP
9064 if test -n "$MKTEMP"; then
9065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9066 $as_echo "$MKTEMP" >&6; }
9067 else
9068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9069 $as_echo "no" >&6; }
9070 fi
9071 
9072 
9073   test -n "$MKTEMP" && break
9074 done
9075 
9076     else
9077       # If it succeeded, then it was overridden by the user. We will use it
9078       # for the tool.
9079 
9080       # First remove it from the list of overridden variables, so we can test
9081       # for unknown variables in the end.
9082       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9083 
9084       # Check if we try to supply an empty value
9085       if test "x$MKTEMP" = x; then
9086         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
9087 $as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
9088         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9089 $as_echo_n "checking for MKTEMP... " >&6; }
9090         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9091 $as_echo "disabled" >&6; }
9092       else
9093         # Check if the provided tool contains a complete path.
9094         tool_specified="$MKTEMP"
9095         tool_basename="${tool_specified##*/}"
9096         if test "x$tool_basename" = "x$tool_specified"; then
9097           # A command without a complete path is provided, search $PATH.
9098           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
9099 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
9100           # Extract the first word of "$tool_basename", so it can be a program name with args.
9101 set dummy $tool_basename; ac_word=$2
9102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9103 $as_echo_n "checking for $ac_word... " >&6; }
9104 if ${ac_cv_path_MKTEMP+:} false; then :
9105   $as_echo_n "(cached) " >&6
9106 else
9107   case $MKTEMP in
9108   [\\/]* | ?:[\\/]*)
9109   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
9110   ;;
9111   *)
9112   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9113 for as_dir in $PATH
9114 do
9115   IFS=$as_save_IFS
9116   test -z "$as_dir" && as_dir=.
9117     for ac_exec_ext in '' $ac_executable_extensions; do
9118   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9119     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
9120     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9121     break 2
9122   fi
9123 done
9124   done
9125 IFS=$as_save_IFS
9126 
9127   ;;
9128 esac
9129 fi
9130 MKTEMP=$ac_cv_path_MKTEMP
9131 if test -n "$MKTEMP"; then
9132   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
9133 $as_echo "$MKTEMP" >&6; }
9134 else
9135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9136 $as_echo "no" >&6; }
9137 fi
9138 
9139 
9140           if test "x$MKTEMP" = x; then
9141             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9142           fi
9143         else
9144           # Otherwise we believe it is a complete path. Use it as it is.
9145           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
9146 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
9147           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
9148 $as_echo_n "checking for MKTEMP... " >&6; }
9149           if test ! -x "$tool_specified"; then
9150             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9151 $as_echo "not found" >&6; }
9152             as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
9153           fi
9154           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9155 $as_echo "$tool_specified" >&6; }
9156         fi
9157       fi
9158     fi
9159 
9160   fi
9161 
9162 
9163 
9164   if test "x$MKTEMP" = x; then
9165     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
9166   fi
9167 
9168 
9169 
9170 
9171 
9172   # Publish this variable in the help.
9173 
9174 
9175   if [ -z "${MV+x}" ]; then
9176     # The variable is not set by user, try to locate tool using the code snippet
9177     for ac_prog in mv
9178 do
9179   # Extract the first word of "$ac_prog", so it can be a program name with args.
9180 set dummy $ac_prog; ac_word=$2
9181 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9182 $as_echo_n "checking for $ac_word... " >&6; }
9183 if ${ac_cv_path_MV+:} false; then :
9184   $as_echo_n "(cached) " >&6
9185 else
9186   case $MV in
9187   [\\/]* | ?:[\\/]*)
9188   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9189   ;;
9190   *)
9191   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9192 for as_dir in $PATH
9193 do
9194   IFS=$as_save_IFS
9195   test -z "$as_dir" && as_dir=.
9196     for ac_exec_ext in '' $ac_executable_extensions; do
9197   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9198     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9199     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9200     break 2
9201   fi
9202 done
9203   done
9204 IFS=$as_save_IFS
9205 
9206   ;;
9207 esac
9208 fi
9209 MV=$ac_cv_path_MV
9210 if test -n "$MV"; then
9211   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9212 $as_echo "$MV" >&6; }
9213 else
9214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9215 $as_echo "no" >&6; }
9216 fi
9217 
9218 
9219   test -n "$MV" && break
9220 done
9221 
9222   else
9223     # The variable is set, but is it from the command line or the environment?
9224 
9225     # Try to remove the string !MV! from our list.
9226     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
9227     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9228       # If it failed, the variable was not from the command line. Ignore it,
9229       # but warn the user (except for BASH, which is always set by the calling BASH).
9230       if test "xMV" != xBASH; then
9231         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
9232 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
9233       fi
9234       # Try to locate tool using the code snippet
9235       for ac_prog in mv
9236 do
9237   # Extract the first word of "$ac_prog", so it can be a program name with args.
9238 set dummy $ac_prog; ac_word=$2
9239 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9240 $as_echo_n "checking for $ac_word... " >&6; }
9241 if ${ac_cv_path_MV+:} false; then :
9242   $as_echo_n "(cached) " >&6
9243 else
9244   case $MV in
9245   [\\/]* | ?:[\\/]*)
9246   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9247   ;;
9248   *)
9249   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9250 for as_dir in $PATH
9251 do
9252   IFS=$as_save_IFS
9253   test -z "$as_dir" && as_dir=.
9254     for ac_exec_ext in '' $ac_executable_extensions; do
9255   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9256     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9257     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9258     break 2
9259   fi
9260 done
9261   done
9262 IFS=$as_save_IFS
9263 
9264   ;;
9265 esac
9266 fi
9267 MV=$ac_cv_path_MV
9268 if test -n "$MV"; then
9269   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9270 $as_echo "$MV" >&6; }
9271 else
9272   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9273 $as_echo "no" >&6; }
9274 fi
9275 
9276 
9277   test -n "$MV" && break
9278 done
9279 
9280     else
9281       # If it succeeded, then it was overridden by the user. We will use it
9282       # for the tool.
9283 
9284       # First remove it from the list of overridden variables, so we can test
9285       # for unknown variables in the end.
9286       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9287 
9288       # Check if we try to supply an empty value
9289       if test "x$MV" = x; then
9290         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
9291 $as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
9292         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9293 $as_echo_n "checking for MV... " >&6; }
9294         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9295 $as_echo "disabled" >&6; }
9296       else
9297         # Check if the provided tool contains a complete path.
9298         tool_specified="$MV"
9299         tool_basename="${tool_specified##*/}"
9300         if test "x$tool_basename" = "x$tool_specified"; then
9301           # A command without a complete path is provided, search $PATH.
9302           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
9303 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
9304           # Extract the first word of "$tool_basename", so it can be a program name with args.
9305 set dummy $tool_basename; ac_word=$2
9306 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9307 $as_echo_n "checking for $ac_word... " >&6; }
9308 if ${ac_cv_path_MV+:} false; then :
9309   $as_echo_n "(cached) " >&6
9310 else
9311   case $MV in
9312   [\\/]* | ?:[\\/]*)
9313   ac_cv_path_MV="$MV" # Let the user override the test with a path.
9314   ;;
9315   *)
9316   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9317 for as_dir in $PATH
9318 do
9319   IFS=$as_save_IFS
9320   test -z "$as_dir" && as_dir=.
9321     for ac_exec_ext in '' $ac_executable_extensions; do
9322   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9323     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
9324     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9325     break 2
9326   fi
9327 done
9328   done
9329 IFS=$as_save_IFS
9330 
9331   ;;
9332 esac
9333 fi
9334 MV=$ac_cv_path_MV
9335 if test -n "$MV"; then
9336   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
9337 $as_echo "$MV" >&6; }
9338 else
9339   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9340 $as_echo "no" >&6; }
9341 fi
9342 
9343 
9344           if test "x$MV" = x; then
9345             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9346           fi
9347         else
9348           # Otherwise we believe it is a complete path. Use it as it is.
9349           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
9350 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
9351           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
9352 $as_echo_n "checking for MV... " >&6; }
9353           if test ! -x "$tool_specified"; then
9354             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9355 $as_echo "not found" >&6; }
9356             as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
9357           fi
9358           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9359 $as_echo "$tool_specified" >&6; }
9360         fi
9361       fi
9362     fi
9363 
9364   fi
9365 
9366 
9367 
9368   if test "x$MV" = x; then
9369     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
9370   fi
9371 
9372 
9373 
9374 
9375 
9376   # Publish this variable in the help.
9377 
9378 
9379   if [ -z "${NAWK+x}" ]; then
9380     # The variable is not set by user, try to locate tool using the code snippet
9381     for ac_prog in nawk gawk awk
9382 do
9383   # Extract the first word of "$ac_prog", so it can be a program name with args.
9384 set dummy $ac_prog; ac_word=$2
9385 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9386 $as_echo_n "checking for $ac_word... " >&6; }
9387 if ${ac_cv_path_NAWK+:} false; then :
9388   $as_echo_n "(cached) " >&6
9389 else
9390   case $NAWK in
9391   [\\/]* | ?:[\\/]*)
9392   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9393   ;;
9394   *)
9395   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9396 for as_dir in $PATH
9397 do
9398   IFS=$as_save_IFS
9399   test -z "$as_dir" && as_dir=.
9400     for ac_exec_ext in '' $ac_executable_extensions; do
9401   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9402     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9403     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9404     break 2
9405   fi
9406 done
9407   done
9408 IFS=$as_save_IFS
9409 
9410   ;;
9411 esac
9412 fi
9413 NAWK=$ac_cv_path_NAWK
9414 if test -n "$NAWK"; then
9415   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9416 $as_echo "$NAWK" >&6; }
9417 else
9418   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9419 $as_echo "no" >&6; }
9420 fi
9421 
9422 
9423   test -n "$NAWK" && break
9424 done
9425 
9426   else
9427     # The variable is set, but is it from the command line or the environment?
9428 
9429     # Try to remove the string !NAWK! from our list.
9430     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
9431     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9432       # If it failed, the variable was not from the command line. Ignore it,
9433       # but warn the user (except for BASH, which is always set by the calling BASH).
9434       if test "xNAWK" != xBASH; then
9435         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
9436 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
9437       fi
9438       # Try to locate tool using the code snippet
9439       for ac_prog in nawk gawk awk
9440 do
9441   # Extract the first word of "$ac_prog", so it can be a program name with args.
9442 set dummy $ac_prog; ac_word=$2
9443 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9444 $as_echo_n "checking for $ac_word... " >&6; }
9445 if ${ac_cv_path_NAWK+:} false; then :
9446   $as_echo_n "(cached) " >&6
9447 else
9448   case $NAWK in
9449   [\\/]* | ?:[\\/]*)
9450   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9451   ;;
9452   *)
9453   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9454 for as_dir in $PATH
9455 do
9456   IFS=$as_save_IFS
9457   test -z "$as_dir" && as_dir=.
9458     for ac_exec_ext in '' $ac_executable_extensions; do
9459   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9460     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9461     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9462     break 2
9463   fi
9464 done
9465   done
9466 IFS=$as_save_IFS
9467 
9468   ;;
9469 esac
9470 fi
9471 NAWK=$ac_cv_path_NAWK
9472 if test -n "$NAWK"; then
9473   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9474 $as_echo "$NAWK" >&6; }
9475 else
9476   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9477 $as_echo "no" >&6; }
9478 fi
9479 
9480 
9481   test -n "$NAWK" && break
9482 done
9483 
9484     else
9485       # If it succeeded, then it was overridden by the user. We will use it
9486       # for the tool.
9487 
9488       # First remove it from the list of overridden variables, so we can test
9489       # for unknown variables in the end.
9490       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9491 
9492       # Check if we try to supply an empty value
9493       if test "x$NAWK" = x; then
9494         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
9495 $as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
9496         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9497 $as_echo_n "checking for NAWK... " >&6; }
9498         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9499 $as_echo "disabled" >&6; }
9500       else
9501         # Check if the provided tool contains a complete path.
9502         tool_specified="$NAWK"
9503         tool_basename="${tool_specified##*/}"
9504         if test "x$tool_basename" = "x$tool_specified"; then
9505           # A command without a complete path is provided, search $PATH.
9506           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
9507 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
9508           # Extract the first word of "$tool_basename", so it can be a program name with args.
9509 set dummy $tool_basename; ac_word=$2
9510 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9511 $as_echo_n "checking for $ac_word... " >&6; }
9512 if ${ac_cv_path_NAWK+:} false; then :
9513   $as_echo_n "(cached) " >&6
9514 else
9515   case $NAWK in
9516   [\\/]* | ?:[\\/]*)
9517   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
9518   ;;
9519   *)
9520   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9521 for as_dir in $PATH
9522 do
9523   IFS=$as_save_IFS
9524   test -z "$as_dir" && as_dir=.
9525     for ac_exec_ext in '' $ac_executable_extensions; do
9526   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9527     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
9528     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9529     break 2
9530   fi
9531 done
9532   done
9533 IFS=$as_save_IFS
9534 
9535   ;;
9536 esac
9537 fi
9538 NAWK=$ac_cv_path_NAWK
9539 if test -n "$NAWK"; then
9540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
9541 $as_echo "$NAWK" >&6; }
9542 else
9543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9544 $as_echo "no" >&6; }
9545 fi
9546 
9547 
9548           if test "x$NAWK" = x; then
9549             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9550           fi
9551         else
9552           # Otherwise we believe it is a complete path. Use it as it is.
9553           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
9554 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
9555           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
9556 $as_echo_n "checking for NAWK... " >&6; }
9557           if test ! -x "$tool_specified"; then
9558             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9559 $as_echo "not found" >&6; }
9560             as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
9561           fi
9562           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9563 $as_echo "$tool_specified" >&6; }
9564         fi
9565       fi
9566     fi
9567 
9568   fi
9569 
9570 
9571 
9572   if test "x$NAWK" = x; then
9573     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
9574   fi
9575 
9576 
9577 
9578 
9579 
9580   # Publish this variable in the help.
9581 
9582 
9583   if [ -z "${PRINTF+x}" ]; then
9584     # The variable is not set by user, try to locate tool using the code snippet
9585     for ac_prog in printf
9586 do
9587   # Extract the first word of "$ac_prog", so it can be a program name with args.
9588 set dummy $ac_prog; ac_word=$2
9589 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9590 $as_echo_n "checking for $ac_word... " >&6; }
9591 if ${ac_cv_path_PRINTF+:} false; then :
9592   $as_echo_n "(cached) " >&6
9593 else
9594   case $PRINTF in
9595   [\\/]* | ?:[\\/]*)
9596   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9597   ;;
9598   *)
9599   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9600 for as_dir in $PATH
9601 do
9602   IFS=$as_save_IFS
9603   test -z "$as_dir" && as_dir=.
9604     for ac_exec_ext in '' $ac_executable_extensions; do
9605   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9606     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9607     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9608     break 2
9609   fi
9610 done
9611   done
9612 IFS=$as_save_IFS
9613 
9614   ;;
9615 esac
9616 fi
9617 PRINTF=$ac_cv_path_PRINTF
9618 if test -n "$PRINTF"; then
9619   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9620 $as_echo "$PRINTF" >&6; }
9621 else
9622   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9623 $as_echo "no" >&6; }
9624 fi
9625 
9626 
9627   test -n "$PRINTF" && break
9628 done
9629 
9630   else
9631     # The variable is set, but is it from the command line or the environment?
9632 
9633     # Try to remove the string !PRINTF! from our list.
9634     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
9635     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9636       # If it failed, the variable was not from the command line. Ignore it,
9637       # but warn the user (except for BASH, which is always set by the calling BASH).
9638       if test "xPRINTF" != xBASH; then
9639         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
9640 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
9641       fi
9642       # Try to locate tool using the code snippet
9643       for ac_prog in printf
9644 do
9645   # Extract the first word of "$ac_prog", so it can be a program name with args.
9646 set dummy $ac_prog; ac_word=$2
9647 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9648 $as_echo_n "checking for $ac_word... " >&6; }
9649 if ${ac_cv_path_PRINTF+:} false; then :
9650   $as_echo_n "(cached) " >&6
9651 else
9652   case $PRINTF in
9653   [\\/]* | ?:[\\/]*)
9654   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9655   ;;
9656   *)
9657   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9658 for as_dir in $PATH
9659 do
9660   IFS=$as_save_IFS
9661   test -z "$as_dir" && as_dir=.
9662     for ac_exec_ext in '' $ac_executable_extensions; do
9663   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9664     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9665     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9666     break 2
9667   fi
9668 done
9669   done
9670 IFS=$as_save_IFS
9671 
9672   ;;
9673 esac
9674 fi
9675 PRINTF=$ac_cv_path_PRINTF
9676 if test -n "$PRINTF"; then
9677   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9678 $as_echo "$PRINTF" >&6; }
9679 else
9680   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9681 $as_echo "no" >&6; }
9682 fi
9683 
9684 
9685   test -n "$PRINTF" && break
9686 done
9687 
9688     else
9689       # If it succeeded, then it was overridden by the user. We will use it
9690       # for the tool.
9691 
9692       # First remove it from the list of overridden variables, so we can test
9693       # for unknown variables in the end.
9694       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9695 
9696       # Check if we try to supply an empty value
9697       if test "x$PRINTF" = x; then
9698         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
9699 $as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
9700         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9701 $as_echo_n "checking for PRINTF... " >&6; }
9702         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9703 $as_echo "disabled" >&6; }
9704       else
9705         # Check if the provided tool contains a complete path.
9706         tool_specified="$PRINTF"
9707         tool_basename="${tool_specified##*/}"
9708         if test "x$tool_basename" = "x$tool_specified"; then
9709           # A command without a complete path is provided, search $PATH.
9710           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
9711 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
9712           # Extract the first word of "$tool_basename", so it can be a program name with args.
9713 set dummy $tool_basename; ac_word=$2
9714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9715 $as_echo_n "checking for $ac_word... " >&6; }
9716 if ${ac_cv_path_PRINTF+:} false; then :
9717   $as_echo_n "(cached) " >&6
9718 else
9719   case $PRINTF in
9720   [\\/]* | ?:[\\/]*)
9721   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
9722   ;;
9723   *)
9724   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9725 for as_dir in $PATH
9726 do
9727   IFS=$as_save_IFS
9728   test -z "$as_dir" && as_dir=.
9729     for ac_exec_ext in '' $ac_executable_extensions; do
9730   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9731     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
9732     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9733     break 2
9734   fi
9735 done
9736   done
9737 IFS=$as_save_IFS
9738 
9739   ;;
9740 esac
9741 fi
9742 PRINTF=$ac_cv_path_PRINTF
9743 if test -n "$PRINTF"; then
9744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
9745 $as_echo "$PRINTF" >&6; }
9746 else
9747   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9748 $as_echo "no" >&6; }
9749 fi
9750 
9751 
9752           if test "x$PRINTF" = x; then
9753             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9754           fi
9755         else
9756           # Otherwise we believe it is a complete path. Use it as it is.
9757           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
9758 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
9759           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
9760 $as_echo_n "checking for PRINTF... " >&6; }
9761           if test ! -x "$tool_specified"; then
9762             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9763 $as_echo "not found" >&6; }
9764             as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
9765           fi
9766           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9767 $as_echo "$tool_specified" >&6; }
9768         fi
9769       fi
9770     fi
9771 
9772   fi
9773 
9774 
9775 
9776   if test "x$PRINTF" = x; then
9777     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
9778   fi
9779 
9780 
9781 
9782 
9783 
9784   # Publish this variable in the help.
9785 
9786 
9787   if [ -z "${RM+x}" ]; then
9788     # The variable is not set by user, try to locate tool using the code snippet
9789     for ac_prog in rm
9790 do
9791   # Extract the first word of "$ac_prog", so it can be a program name with args.
9792 set dummy $ac_prog; ac_word=$2
9793 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9794 $as_echo_n "checking for $ac_word... " >&6; }
9795 if ${ac_cv_path_RM+:} false; then :
9796   $as_echo_n "(cached) " >&6
9797 else
9798   case $RM in
9799   [\\/]* | ?:[\\/]*)
9800   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9801   ;;
9802   *)
9803   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9804 for as_dir in $PATH
9805 do
9806   IFS=$as_save_IFS
9807   test -z "$as_dir" && as_dir=.
9808     for ac_exec_ext in '' $ac_executable_extensions; do
9809   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9810     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9811     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9812     break 2
9813   fi
9814 done
9815   done
9816 IFS=$as_save_IFS
9817 
9818   ;;
9819 esac
9820 fi
9821 RM=$ac_cv_path_RM
9822 if test -n "$RM"; then
9823   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9824 $as_echo "$RM" >&6; }
9825 else
9826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9827 $as_echo "no" >&6; }
9828 fi
9829 
9830 
9831   test -n "$RM" && break
9832 done
9833 
9834   else
9835     # The variable is set, but is it from the command line or the environment?
9836 
9837     # Try to remove the string !RM! from our list.
9838     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
9839     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9840       # If it failed, the variable was not from the command line. Ignore it,
9841       # but warn the user (except for BASH, which is always set by the calling BASH).
9842       if test "xRM" != xBASH; then
9843         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
9844 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
9845       fi
9846       # Try to locate tool using the code snippet
9847       for ac_prog in rm
9848 do
9849   # Extract the first word of "$ac_prog", so it can be a program name with args.
9850 set dummy $ac_prog; ac_word=$2
9851 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9852 $as_echo_n "checking for $ac_word... " >&6; }
9853 if ${ac_cv_path_RM+:} false; then :
9854   $as_echo_n "(cached) " >&6
9855 else
9856   case $RM in
9857   [\\/]* | ?:[\\/]*)
9858   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9859   ;;
9860   *)
9861   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9862 for as_dir in $PATH
9863 do
9864   IFS=$as_save_IFS
9865   test -z "$as_dir" && as_dir=.
9866     for ac_exec_ext in '' $ac_executable_extensions; do
9867   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9868     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9869     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9870     break 2
9871   fi
9872 done
9873   done
9874 IFS=$as_save_IFS
9875 
9876   ;;
9877 esac
9878 fi
9879 RM=$ac_cv_path_RM
9880 if test -n "$RM"; then
9881   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9882 $as_echo "$RM" >&6; }
9883 else
9884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9885 $as_echo "no" >&6; }
9886 fi
9887 
9888 
9889   test -n "$RM" && break
9890 done
9891 
9892     else
9893       # If it succeeded, then it was overridden by the user. We will use it
9894       # for the tool.
9895 
9896       # First remove it from the list of overridden variables, so we can test
9897       # for unknown variables in the end.
9898       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9899 
9900       # Check if we try to supply an empty value
9901       if test "x$RM" = x; then
9902         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
9903 $as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
9904         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9905 $as_echo_n "checking for RM... " >&6; }
9906         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
9907 $as_echo "disabled" >&6; }
9908       else
9909         # Check if the provided tool contains a complete path.
9910         tool_specified="$RM"
9911         tool_basename="${tool_specified##*/}"
9912         if test "x$tool_basename" = "x$tool_specified"; then
9913           # A command without a complete path is provided, search $PATH.
9914           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9915 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9916           # Extract the first word of "$tool_basename", so it can be a program name with args.
9917 set dummy $tool_basename; ac_word=$2
9918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9919 $as_echo_n "checking for $ac_word... " >&6; }
9920 if ${ac_cv_path_RM+:} false; then :
9921   $as_echo_n "(cached) " >&6
9922 else
9923   case $RM in
9924   [\\/]* | ?:[\\/]*)
9925   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9926   ;;
9927   *)
9928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9929 for as_dir in $PATH
9930 do
9931   IFS=$as_save_IFS
9932   test -z "$as_dir" && as_dir=.
9933     for ac_exec_ext in '' $ac_executable_extensions; do
9934   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9935     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9936     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9937     break 2
9938   fi
9939 done
9940   done
9941 IFS=$as_save_IFS
9942 
9943   ;;
9944 esac
9945 fi
9946 RM=$ac_cv_path_RM
9947 if test -n "$RM"; then
9948   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9949 $as_echo "$RM" >&6; }
9950 else
9951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9952 $as_echo "no" >&6; }
9953 fi
9954 
9955 
9956           if test "x$RM" = x; then
9957             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9958           fi
9959         else
9960           # Otherwise we believe it is a complete path. Use it as it is.
9961           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9962 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9963           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9964 $as_echo_n "checking for RM... " >&6; }
9965           if test ! -x "$tool_specified"; then
9966             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9967 $as_echo "not found" >&6; }
9968             as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9969           fi
9970           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9971 $as_echo "$tool_specified" >&6; }
9972         fi
9973       fi
9974     fi
9975 
9976   fi
9977 
9978 
9979 
9980   if test "x$RM" = x; then
9981     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9982   fi
9983 
9984 
9985 
9986 
9987 
9988   # Publish this variable in the help.
9989 
9990 
9991   if [ -z "${RMDIR+x}" ]; then
9992     # The variable is not set by user, try to locate tool using the code snippet
9993     for ac_prog in rmdir
9994 do
9995   # Extract the first word of "$ac_prog", so it can be a program name with args.
9996 set dummy $ac_prog; ac_word=$2
9997 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9998 $as_echo_n "checking for $ac_word... " >&6; }
9999 if ${ac_cv_path_RMDIR+:} false; then :
10000   $as_echo_n "(cached) " >&6
10001 else
10002   case $RMDIR in
10003   [\\/]* | ?:[\\/]*)
10004   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10005   ;;
10006   *)
10007   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10008 for as_dir in $PATH
10009 do
10010   IFS=$as_save_IFS
10011   test -z "$as_dir" && as_dir=.
10012     for ac_exec_ext in '' $ac_executable_extensions; do
10013   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10014     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10015     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10016     break 2
10017   fi
10018 done
10019   done
10020 IFS=$as_save_IFS
10021 
10022   ;;
10023 esac
10024 fi
10025 RMDIR=$ac_cv_path_RMDIR
10026 if test -n "$RMDIR"; then
10027   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10028 $as_echo "$RMDIR" >&6; }
10029 else
10030   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10031 $as_echo "no" >&6; }
10032 fi
10033 
10034 
10035   test -n "$RMDIR" && break
10036 done
10037 
10038   else
10039     # The variable is set, but is it from the command line or the environment?
10040 
10041     # Try to remove the string !RMDIR! from our list.
10042     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
10043     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10044       # If it failed, the variable was not from the command line. Ignore it,
10045       # but warn the user (except for BASH, which is always set by the calling BASH).
10046       if test "xRMDIR" != xBASH; then
10047         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
10048 $as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
10049       fi
10050       # Try to locate tool using the code snippet
10051       for ac_prog in rmdir
10052 do
10053   # Extract the first word of "$ac_prog", so it can be a program name with args.
10054 set dummy $ac_prog; ac_word=$2
10055 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10056 $as_echo_n "checking for $ac_word... " >&6; }
10057 if ${ac_cv_path_RMDIR+:} false; then :
10058   $as_echo_n "(cached) " >&6
10059 else
10060   case $RMDIR in
10061   [\\/]* | ?:[\\/]*)
10062   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10063   ;;
10064   *)
10065   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10066 for as_dir in $PATH
10067 do
10068   IFS=$as_save_IFS
10069   test -z "$as_dir" && as_dir=.
10070     for ac_exec_ext in '' $ac_executable_extensions; do
10071   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10072     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10073     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10074     break 2
10075   fi
10076 done
10077   done
10078 IFS=$as_save_IFS
10079 
10080   ;;
10081 esac
10082 fi
10083 RMDIR=$ac_cv_path_RMDIR
10084 if test -n "$RMDIR"; then
10085   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10086 $as_echo "$RMDIR" >&6; }
10087 else
10088   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10089 $as_echo "no" >&6; }
10090 fi
10091 
10092 
10093   test -n "$RMDIR" && break
10094 done
10095 
10096     else
10097       # If it succeeded, then it was overridden by the user. We will use it
10098       # for the tool.
10099 
10100       # First remove it from the list of overridden variables, so we can test
10101       # for unknown variables in the end.
10102       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10103 
10104       # Check if we try to supply an empty value
10105       if test "x$RMDIR" = x; then
10106         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
10107 $as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
10108         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10109 $as_echo_n "checking for RMDIR... " >&6; }
10110         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10111 $as_echo "disabled" >&6; }
10112       else
10113         # Check if the provided tool contains a complete path.
10114         tool_specified="$RMDIR"
10115         tool_basename="${tool_specified##*/}"
10116         if test "x$tool_basename" = "x$tool_specified"; then
10117           # A command without a complete path is provided, search $PATH.
10118           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
10119 $as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
10120           # Extract the first word of "$tool_basename", so it can be a program name with args.
10121 set dummy $tool_basename; ac_word=$2
10122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10123 $as_echo_n "checking for $ac_word... " >&6; }
10124 if ${ac_cv_path_RMDIR+:} false; then :
10125   $as_echo_n "(cached) " >&6
10126 else
10127   case $RMDIR in
10128   [\\/]* | ?:[\\/]*)
10129   ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
10130   ;;
10131   *)
10132   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10133 for as_dir in $PATH
10134 do
10135   IFS=$as_save_IFS
10136   test -z "$as_dir" && as_dir=.
10137     for ac_exec_ext in '' $ac_executable_extensions; do
10138   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10139     ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
10140     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10141     break 2
10142   fi
10143 done
10144   done
10145 IFS=$as_save_IFS
10146 
10147   ;;
10148 esac
10149 fi
10150 RMDIR=$ac_cv_path_RMDIR
10151 if test -n "$RMDIR"; then
10152   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
10153 $as_echo "$RMDIR" >&6; }
10154 else
10155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10156 $as_echo "no" >&6; }
10157 fi
10158 
10159 
10160           if test "x$RMDIR" = x; then
10161             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10162           fi
10163         else
10164           # Otherwise we believe it is a complete path. Use it as it is.
10165           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
10166 $as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
10167           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
10168 $as_echo_n "checking for RMDIR... " >&6; }
10169           if test ! -x "$tool_specified"; then
10170             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10171 $as_echo "not found" >&6; }
10172             as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
10173           fi
10174           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10175 $as_echo "$tool_specified" >&6; }
10176         fi
10177       fi
10178     fi
10179 
10180   fi
10181 
10182 
10183 
10184   if test "x$RMDIR" = x; then
10185     as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
10186   fi
10187 
10188 
10189 
10190 
10191 
10192   # Publish this variable in the help.
10193 
10194 
10195   if [ -z "${SH+x}" ]; then
10196     # The variable is not set by user, try to locate tool using the code snippet
10197     for ac_prog in sh
10198 do
10199   # Extract the first word of "$ac_prog", so it can be a program name with args.
10200 set dummy $ac_prog; ac_word=$2
10201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10202 $as_echo_n "checking for $ac_word... " >&6; }
10203 if ${ac_cv_path_SH+:} false; then :
10204   $as_echo_n "(cached) " >&6
10205 else
10206   case $SH in
10207   [\\/]* | ?:[\\/]*)
10208   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10209   ;;
10210   *)
10211   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10212 for as_dir in $PATH
10213 do
10214   IFS=$as_save_IFS
10215   test -z "$as_dir" && as_dir=.
10216     for ac_exec_ext in '' $ac_executable_extensions; do
10217   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10218     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10219     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10220     break 2
10221   fi
10222 done
10223   done
10224 IFS=$as_save_IFS
10225 
10226   ;;
10227 esac
10228 fi
10229 SH=$ac_cv_path_SH
10230 if test -n "$SH"; then
10231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10232 $as_echo "$SH" >&6; }
10233 else
10234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10235 $as_echo "no" >&6; }
10236 fi
10237 
10238 
10239   test -n "$SH" && break
10240 done
10241 
10242   else
10243     # The variable is set, but is it from the command line or the environment?
10244 
10245     # Try to remove the string !SH! from our list.
10246     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
10247     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10248       # If it failed, the variable was not from the command line. Ignore it,
10249       # but warn the user (except for BASH, which is always set by the calling BASH).
10250       if test "xSH" != xBASH; then
10251         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
10252 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
10253       fi
10254       # Try to locate tool using the code snippet
10255       for ac_prog in sh
10256 do
10257   # Extract the first word of "$ac_prog", so it can be a program name with args.
10258 set dummy $ac_prog; ac_word=$2
10259 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10260 $as_echo_n "checking for $ac_word... " >&6; }
10261 if ${ac_cv_path_SH+:} false; then :
10262   $as_echo_n "(cached) " >&6
10263 else
10264   case $SH in
10265   [\\/]* | ?:[\\/]*)
10266   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10267   ;;
10268   *)
10269   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10270 for as_dir in $PATH
10271 do
10272   IFS=$as_save_IFS
10273   test -z "$as_dir" && as_dir=.
10274     for ac_exec_ext in '' $ac_executable_extensions; do
10275   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10276     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10277     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10278     break 2
10279   fi
10280 done
10281   done
10282 IFS=$as_save_IFS
10283 
10284   ;;
10285 esac
10286 fi
10287 SH=$ac_cv_path_SH
10288 if test -n "$SH"; then
10289   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10290 $as_echo "$SH" >&6; }
10291 else
10292   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10293 $as_echo "no" >&6; }
10294 fi
10295 
10296 
10297   test -n "$SH" && break
10298 done
10299 
10300     else
10301       # If it succeeded, then it was overridden by the user. We will use it
10302       # for the tool.
10303 
10304       # First remove it from the list of overridden variables, so we can test
10305       # for unknown variables in the end.
10306       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10307 
10308       # Check if we try to supply an empty value
10309       if test "x$SH" = x; then
10310         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
10311 $as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
10312         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10313 $as_echo_n "checking for SH... " >&6; }
10314         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10315 $as_echo "disabled" >&6; }
10316       else
10317         # Check if the provided tool contains a complete path.
10318         tool_specified="$SH"
10319         tool_basename="${tool_specified##*/}"
10320         if test "x$tool_basename" = "x$tool_specified"; then
10321           # A command without a complete path is provided, search $PATH.
10322           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
10323 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
10324           # Extract the first word of "$tool_basename", so it can be a program name with args.
10325 set dummy $tool_basename; ac_word=$2
10326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10327 $as_echo_n "checking for $ac_word... " >&6; }
10328 if ${ac_cv_path_SH+:} false; then :
10329   $as_echo_n "(cached) " >&6
10330 else
10331   case $SH in
10332   [\\/]* | ?:[\\/]*)
10333   ac_cv_path_SH="$SH" # Let the user override the test with a path.
10334   ;;
10335   *)
10336   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10337 for as_dir in $PATH
10338 do
10339   IFS=$as_save_IFS
10340   test -z "$as_dir" && as_dir=.
10341     for ac_exec_ext in '' $ac_executable_extensions; do
10342   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10343     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
10344     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10345     break 2
10346   fi
10347 done
10348   done
10349 IFS=$as_save_IFS
10350 
10351   ;;
10352 esac
10353 fi
10354 SH=$ac_cv_path_SH
10355 if test -n "$SH"; then
10356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
10357 $as_echo "$SH" >&6; }
10358 else
10359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10360 $as_echo "no" >&6; }
10361 fi
10362 
10363 
10364           if test "x$SH" = x; then
10365             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10366           fi
10367         else
10368           # Otherwise we believe it is a complete path. Use it as it is.
10369           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
10370 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
10371           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
10372 $as_echo_n "checking for SH... " >&6; }
10373           if test ! -x "$tool_specified"; then
10374             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10375 $as_echo "not found" >&6; }
10376             as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
10377           fi
10378           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10379 $as_echo "$tool_specified" >&6; }
10380         fi
10381       fi
10382     fi
10383 
10384   fi
10385 
10386 
10387 
10388   if test "x$SH" = x; then
10389     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
10390   fi
10391 
10392 
10393 
10394 
10395 
10396   # Publish this variable in the help.
10397 
10398 
10399   if [ -z "${SORT+x}" ]; then
10400     # The variable is not set by user, try to locate tool using the code snippet
10401     for ac_prog in sort
10402 do
10403   # Extract the first word of "$ac_prog", so it can be a program name with args.
10404 set dummy $ac_prog; ac_word=$2
10405 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10406 $as_echo_n "checking for $ac_word... " >&6; }
10407 if ${ac_cv_path_SORT+:} false; then :
10408   $as_echo_n "(cached) " >&6
10409 else
10410   case $SORT in
10411   [\\/]* | ?:[\\/]*)
10412   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10413   ;;
10414   *)
10415   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10416 for as_dir in $PATH
10417 do
10418   IFS=$as_save_IFS
10419   test -z "$as_dir" && as_dir=.
10420     for ac_exec_ext in '' $ac_executable_extensions; do
10421   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10422     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10423     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10424     break 2
10425   fi
10426 done
10427   done
10428 IFS=$as_save_IFS
10429 
10430   ;;
10431 esac
10432 fi
10433 SORT=$ac_cv_path_SORT
10434 if test -n "$SORT"; then
10435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10436 $as_echo "$SORT" >&6; }
10437 else
10438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10439 $as_echo "no" >&6; }
10440 fi
10441 
10442 
10443   test -n "$SORT" && break
10444 done
10445 
10446   else
10447     # The variable is set, but is it from the command line or the environment?
10448 
10449     # Try to remove the string !SORT! from our list.
10450     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
10451     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10452       # If it failed, the variable was not from the command line. Ignore it,
10453       # but warn the user (except for BASH, which is always set by the calling BASH).
10454       if test "xSORT" != xBASH; then
10455         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
10456 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
10457       fi
10458       # Try to locate tool using the code snippet
10459       for ac_prog in sort
10460 do
10461   # Extract the first word of "$ac_prog", so it can be a program name with args.
10462 set dummy $ac_prog; ac_word=$2
10463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10464 $as_echo_n "checking for $ac_word... " >&6; }
10465 if ${ac_cv_path_SORT+:} false; then :
10466   $as_echo_n "(cached) " >&6
10467 else
10468   case $SORT in
10469   [\\/]* | ?:[\\/]*)
10470   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10471   ;;
10472   *)
10473   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10474 for as_dir in $PATH
10475 do
10476   IFS=$as_save_IFS
10477   test -z "$as_dir" && as_dir=.
10478     for ac_exec_ext in '' $ac_executable_extensions; do
10479   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10480     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10481     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10482     break 2
10483   fi
10484 done
10485   done
10486 IFS=$as_save_IFS
10487 
10488   ;;
10489 esac
10490 fi
10491 SORT=$ac_cv_path_SORT
10492 if test -n "$SORT"; then
10493   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10494 $as_echo "$SORT" >&6; }
10495 else
10496   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10497 $as_echo "no" >&6; }
10498 fi
10499 
10500 
10501   test -n "$SORT" && break
10502 done
10503 
10504     else
10505       # If it succeeded, then it was overridden by the user. We will use it
10506       # for the tool.
10507 
10508       # First remove it from the list of overridden variables, so we can test
10509       # for unknown variables in the end.
10510       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10511 
10512       # Check if we try to supply an empty value
10513       if test "x$SORT" = x; then
10514         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
10515 $as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
10516         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10517 $as_echo_n "checking for SORT... " >&6; }
10518         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10519 $as_echo "disabled" >&6; }
10520       else
10521         # Check if the provided tool contains a complete path.
10522         tool_specified="$SORT"
10523         tool_basename="${tool_specified##*/}"
10524         if test "x$tool_basename" = "x$tool_specified"; then
10525           # A command without a complete path is provided, search $PATH.
10526           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
10527 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
10528           # Extract the first word of "$tool_basename", so it can be a program name with args.
10529 set dummy $tool_basename; ac_word=$2
10530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10531 $as_echo_n "checking for $ac_word... " >&6; }
10532 if ${ac_cv_path_SORT+:} false; then :
10533   $as_echo_n "(cached) " >&6
10534 else
10535   case $SORT in
10536   [\\/]* | ?:[\\/]*)
10537   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
10538   ;;
10539   *)
10540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10541 for as_dir in $PATH
10542 do
10543   IFS=$as_save_IFS
10544   test -z "$as_dir" && as_dir=.
10545     for ac_exec_ext in '' $ac_executable_extensions; do
10546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10547     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
10548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10549     break 2
10550   fi
10551 done
10552   done
10553 IFS=$as_save_IFS
10554 
10555   ;;
10556 esac
10557 fi
10558 SORT=$ac_cv_path_SORT
10559 if test -n "$SORT"; then
10560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
10561 $as_echo "$SORT" >&6; }
10562 else
10563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10564 $as_echo "no" >&6; }
10565 fi
10566 
10567 
10568           if test "x$SORT" = x; then
10569             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10570           fi
10571         else
10572           # Otherwise we believe it is a complete path. Use it as it is.
10573           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
10574 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
10575           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
10576 $as_echo_n "checking for SORT... " >&6; }
10577           if test ! -x "$tool_specified"; then
10578             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10579 $as_echo "not found" >&6; }
10580             as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
10581           fi
10582           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10583 $as_echo "$tool_specified" >&6; }
10584         fi
10585       fi
10586     fi
10587 
10588   fi
10589 
10590 
10591 
10592   if test "x$SORT" = x; then
10593     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
10594   fi
10595 
10596 
10597 
10598 
10599 
10600   # Publish this variable in the help.
10601 
10602 
10603   if [ -z "${TAIL+x}" ]; then
10604     # The variable is not set by user, try to locate tool using the code snippet
10605     for ac_prog in tail
10606 do
10607   # Extract the first word of "$ac_prog", so it can be a program name with args.
10608 set dummy $ac_prog; ac_word=$2
10609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10610 $as_echo_n "checking for $ac_word... " >&6; }
10611 if ${ac_cv_path_TAIL+:} false; then :
10612   $as_echo_n "(cached) " >&6
10613 else
10614   case $TAIL in
10615   [\\/]* | ?:[\\/]*)
10616   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10617   ;;
10618   *)
10619   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10620 for as_dir in $PATH
10621 do
10622   IFS=$as_save_IFS
10623   test -z "$as_dir" && as_dir=.
10624     for ac_exec_ext in '' $ac_executable_extensions; do
10625   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10626     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10627     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10628     break 2
10629   fi
10630 done
10631   done
10632 IFS=$as_save_IFS
10633 
10634   ;;
10635 esac
10636 fi
10637 TAIL=$ac_cv_path_TAIL
10638 if test -n "$TAIL"; then
10639   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10640 $as_echo "$TAIL" >&6; }
10641 else
10642   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10643 $as_echo "no" >&6; }
10644 fi
10645 
10646 
10647   test -n "$TAIL" && break
10648 done
10649 
10650   else
10651     # The variable is set, but is it from the command line or the environment?
10652 
10653     # Try to remove the string !TAIL! from our list.
10654     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
10655     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10656       # If it failed, the variable was not from the command line. Ignore it,
10657       # but warn the user (except for BASH, which is always set by the calling BASH).
10658       if test "xTAIL" != xBASH; then
10659         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
10660 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
10661       fi
10662       # Try to locate tool using the code snippet
10663       for ac_prog in tail
10664 do
10665   # Extract the first word of "$ac_prog", so it can be a program name with args.
10666 set dummy $ac_prog; ac_word=$2
10667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10668 $as_echo_n "checking for $ac_word... " >&6; }
10669 if ${ac_cv_path_TAIL+:} false; then :
10670   $as_echo_n "(cached) " >&6
10671 else
10672   case $TAIL in
10673   [\\/]* | ?:[\\/]*)
10674   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10675   ;;
10676   *)
10677   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10678 for as_dir in $PATH
10679 do
10680   IFS=$as_save_IFS
10681   test -z "$as_dir" && as_dir=.
10682     for ac_exec_ext in '' $ac_executable_extensions; do
10683   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10684     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10685     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10686     break 2
10687   fi
10688 done
10689   done
10690 IFS=$as_save_IFS
10691 
10692   ;;
10693 esac
10694 fi
10695 TAIL=$ac_cv_path_TAIL
10696 if test -n "$TAIL"; then
10697   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10698 $as_echo "$TAIL" >&6; }
10699 else
10700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10701 $as_echo "no" >&6; }
10702 fi
10703 
10704 
10705   test -n "$TAIL" && break
10706 done
10707 
10708     else
10709       # If it succeeded, then it was overridden by the user. We will use it
10710       # for the tool.
10711 
10712       # First remove it from the list of overridden variables, so we can test
10713       # for unknown variables in the end.
10714       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10715 
10716       # Check if we try to supply an empty value
10717       if test "x$TAIL" = x; then
10718         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
10719 $as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
10720         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10721 $as_echo_n "checking for TAIL... " >&6; }
10722         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10723 $as_echo "disabled" >&6; }
10724       else
10725         # Check if the provided tool contains a complete path.
10726         tool_specified="$TAIL"
10727         tool_basename="${tool_specified##*/}"
10728         if test "x$tool_basename" = "x$tool_specified"; then
10729           # A command without a complete path is provided, search $PATH.
10730           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
10731 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
10732           # Extract the first word of "$tool_basename", so it can be a program name with args.
10733 set dummy $tool_basename; ac_word=$2
10734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10735 $as_echo_n "checking for $ac_word... " >&6; }
10736 if ${ac_cv_path_TAIL+:} false; then :
10737   $as_echo_n "(cached) " >&6
10738 else
10739   case $TAIL in
10740   [\\/]* | ?:[\\/]*)
10741   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
10742   ;;
10743   *)
10744   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10745 for as_dir in $PATH
10746 do
10747   IFS=$as_save_IFS
10748   test -z "$as_dir" && as_dir=.
10749     for ac_exec_ext in '' $ac_executable_extensions; do
10750   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10751     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
10752     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10753     break 2
10754   fi
10755 done
10756   done
10757 IFS=$as_save_IFS
10758 
10759   ;;
10760 esac
10761 fi
10762 TAIL=$ac_cv_path_TAIL
10763 if test -n "$TAIL"; then
10764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
10765 $as_echo "$TAIL" >&6; }
10766 else
10767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10768 $as_echo "no" >&6; }
10769 fi
10770 
10771 
10772           if test "x$TAIL" = x; then
10773             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10774           fi
10775         else
10776           # Otherwise we believe it is a complete path. Use it as it is.
10777           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
10778 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
10779           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
10780 $as_echo_n "checking for TAIL... " >&6; }
10781           if test ! -x "$tool_specified"; then
10782             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10783 $as_echo "not found" >&6; }
10784             as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
10785           fi
10786           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10787 $as_echo "$tool_specified" >&6; }
10788         fi
10789       fi
10790     fi
10791 
10792   fi
10793 
10794 
10795 
10796   if test "x$TAIL" = x; then
10797     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
10798   fi
10799 
10800 
10801 
10802 
10803 
10804   # Publish this variable in the help.
10805 
10806 
10807   if [ -z "${TAR+x}" ]; then
10808     # The variable is not set by user, try to locate tool using the code snippet
10809     for ac_prog in tar
10810 do
10811   # Extract the first word of "$ac_prog", so it can be a program name with args.
10812 set dummy $ac_prog; ac_word=$2
10813 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10814 $as_echo_n "checking for $ac_word... " >&6; }
10815 if ${ac_cv_path_TAR+:} false; then :
10816   $as_echo_n "(cached) " >&6
10817 else
10818   case $TAR in
10819   [\\/]* | ?:[\\/]*)
10820   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10821   ;;
10822   *)
10823   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10824 for as_dir in $PATH
10825 do
10826   IFS=$as_save_IFS
10827   test -z "$as_dir" && as_dir=.
10828     for ac_exec_ext in '' $ac_executable_extensions; do
10829   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10830     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10831     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10832     break 2
10833   fi
10834 done
10835   done
10836 IFS=$as_save_IFS
10837 
10838   ;;
10839 esac
10840 fi
10841 TAR=$ac_cv_path_TAR
10842 if test -n "$TAR"; then
10843   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10844 $as_echo "$TAR" >&6; }
10845 else
10846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10847 $as_echo "no" >&6; }
10848 fi
10849 
10850 
10851   test -n "$TAR" && break
10852 done
10853 
10854   else
10855     # The variable is set, but is it from the command line or the environment?
10856 
10857     # Try to remove the string !TAR! from our list.
10858     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
10859     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10860       # If it failed, the variable was not from the command line. Ignore it,
10861       # but warn the user (except for BASH, which is always set by the calling BASH).
10862       if test "xTAR" != xBASH; then
10863         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
10864 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
10865       fi
10866       # Try to locate tool using the code snippet
10867       for ac_prog in tar
10868 do
10869   # Extract the first word of "$ac_prog", so it can be a program name with args.
10870 set dummy $ac_prog; ac_word=$2
10871 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10872 $as_echo_n "checking for $ac_word... " >&6; }
10873 if ${ac_cv_path_TAR+:} false; then :
10874   $as_echo_n "(cached) " >&6
10875 else
10876   case $TAR in
10877   [\\/]* | ?:[\\/]*)
10878   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10879   ;;
10880   *)
10881   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10882 for as_dir in $PATH
10883 do
10884   IFS=$as_save_IFS
10885   test -z "$as_dir" && as_dir=.
10886     for ac_exec_ext in '' $ac_executable_extensions; do
10887   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10888     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10889     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10890     break 2
10891   fi
10892 done
10893   done
10894 IFS=$as_save_IFS
10895 
10896   ;;
10897 esac
10898 fi
10899 TAR=$ac_cv_path_TAR
10900 if test -n "$TAR"; then
10901   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10902 $as_echo "$TAR" >&6; }
10903 else
10904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10905 $as_echo "no" >&6; }
10906 fi
10907 
10908 
10909   test -n "$TAR" && break
10910 done
10911 
10912     else
10913       # If it succeeded, then it was overridden by the user. We will use it
10914       # for the tool.
10915 
10916       # First remove it from the list of overridden variables, so we can test
10917       # for unknown variables in the end.
10918       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10919 
10920       # Check if we try to supply an empty value
10921       if test "x$TAR" = x; then
10922         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
10923 $as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
10924         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10925 $as_echo_n "checking for TAR... " >&6; }
10926         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
10927 $as_echo "disabled" >&6; }
10928       else
10929         # Check if the provided tool contains a complete path.
10930         tool_specified="$TAR"
10931         tool_basename="${tool_specified##*/}"
10932         if test "x$tool_basename" = "x$tool_specified"; then
10933           # A command without a complete path is provided, search $PATH.
10934           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
10935 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
10936           # Extract the first word of "$tool_basename", so it can be a program name with args.
10937 set dummy $tool_basename; ac_word=$2
10938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10939 $as_echo_n "checking for $ac_word... " >&6; }
10940 if ${ac_cv_path_TAR+:} false; then :
10941   $as_echo_n "(cached) " >&6
10942 else
10943   case $TAR in
10944   [\\/]* | ?:[\\/]*)
10945   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
10946   ;;
10947   *)
10948   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10949 for as_dir in $PATH
10950 do
10951   IFS=$as_save_IFS
10952   test -z "$as_dir" && as_dir=.
10953     for ac_exec_ext in '' $ac_executable_extensions; do
10954   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10955     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
10956     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10957     break 2
10958   fi
10959 done
10960   done
10961 IFS=$as_save_IFS
10962 
10963   ;;
10964 esac
10965 fi
10966 TAR=$ac_cv_path_TAR
10967 if test -n "$TAR"; then
10968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
10969 $as_echo "$TAR" >&6; }
10970 else
10971   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10972 $as_echo "no" >&6; }
10973 fi
10974 
10975 
10976           if test "x$TAR" = x; then
10977             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10978           fi
10979         else
10980           # Otherwise we believe it is a complete path. Use it as it is.
10981           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
10982 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
10983           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
10984 $as_echo_n "checking for TAR... " >&6; }
10985           if test ! -x "$tool_specified"; then
10986             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10987 $as_echo "not found" >&6; }
10988             as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
10989           fi
10990           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10991 $as_echo "$tool_specified" >&6; }
10992         fi
10993       fi
10994     fi
10995 
10996   fi
10997 
10998 
10999 
11000   if test "x$TAR" = x; then
11001     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
11002   fi
11003 
11004 
11005 
11006 
11007 
11008   # Publish this variable in the help.
11009 
11010 
11011   if [ -z "${TEE+x}" ]; then
11012     # The variable is not set by user, try to locate tool using the code snippet
11013     for ac_prog in tee
11014 do
11015   # Extract the first word of "$ac_prog", so it can be a program name with args.
11016 set dummy $ac_prog; ac_word=$2
11017 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11018 $as_echo_n "checking for $ac_word... " >&6; }
11019 if ${ac_cv_path_TEE+:} false; then :
11020   $as_echo_n "(cached) " >&6
11021 else
11022   case $TEE in
11023   [\\/]* | ?:[\\/]*)
11024   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11025   ;;
11026   *)
11027   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11028 for as_dir in $PATH
11029 do
11030   IFS=$as_save_IFS
11031   test -z "$as_dir" && as_dir=.
11032     for ac_exec_ext in '' $ac_executable_extensions; do
11033   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11034     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11035     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11036     break 2
11037   fi
11038 done
11039   done
11040 IFS=$as_save_IFS
11041 
11042   ;;
11043 esac
11044 fi
11045 TEE=$ac_cv_path_TEE
11046 if test -n "$TEE"; then
11047   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11048 $as_echo "$TEE" >&6; }
11049 else
11050   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11051 $as_echo "no" >&6; }
11052 fi
11053 
11054 
11055   test -n "$TEE" && break
11056 done
11057 
11058   else
11059     # The variable is set, but is it from the command line or the environment?
11060 
11061     # Try to remove the string !TEE! from our list.
11062     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
11063     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11064       # If it failed, the variable was not from the command line. Ignore it,
11065       # but warn the user (except for BASH, which is always set by the calling BASH).
11066       if test "xTEE" != xBASH; then
11067         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
11068 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
11069       fi
11070       # Try to locate tool using the code snippet
11071       for ac_prog in tee
11072 do
11073   # Extract the first word of "$ac_prog", so it can be a program name with args.
11074 set dummy $ac_prog; ac_word=$2
11075 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11076 $as_echo_n "checking for $ac_word... " >&6; }
11077 if ${ac_cv_path_TEE+:} false; then :
11078   $as_echo_n "(cached) " >&6
11079 else
11080   case $TEE in
11081   [\\/]* | ?:[\\/]*)
11082   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11083   ;;
11084   *)
11085   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11086 for as_dir in $PATH
11087 do
11088   IFS=$as_save_IFS
11089   test -z "$as_dir" && as_dir=.
11090     for ac_exec_ext in '' $ac_executable_extensions; do
11091   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11092     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11093     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11094     break 2
11095   fi
11096 done
11097   done
11098 IFS=$as_save_IFS
11099 
11100   ;;
11101 esac
11102 fi
11103 TEE=$ac_cv_path_TEE
11104 if test -n "$TEE"; then
11105   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11106 $as_echo "$TEE" >&6; }
11107 else
11108   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11109 $as_echo "no" >&6; }
11110 fi
11111 
11112 
11113   test -n "$TEE" && break
11114 done
11115 
11116     else
11117       # If it succeeded, then it was overridden by the user. We will use it
11118       # for the tool.
11119 
11120       # First remove it from the list of overridden variables, so we can test
11121       # for unknown variables in the end.
11122       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11123 
11124       # Check if we try to supply an empty value
11125       if test "x$TEE" = x; then
11126         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
11127 $as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
11128         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11129 $as_echo_n "checking for TEE... " >&6; }
11130         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11131 $as_echo "disabled" >&6; }
11132       else
11133         # Check if the provided tool contains a complete path.
11134         tool_specified="$TEE"
11135         tool_basename="${tool_specified##*/}"
11136         if test "x$tool_basename" = "x$tool_specified"; then
11137           # A command without a complete path is provided, search $PATH.
11138           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
11139 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
11140           # Extract the first word of "$tool_basename", so it can be a program name with args.
11141 set dummy $tool_basename; ac_word=$2
11142 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11143 $as_echo_n "checking for $ac_word... " >&6; }
11144 if ${ac_cv_path_TEE+:} false; then :
11145   $as_echo_n "(cached) " >&6
11146 else
11147   case $TEE in
11148   [\\/]* | ?:[\\/]*)
11149   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
11150   ;;
11151   *)
11152   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11153 for as_dir in $PATH
11154 do
11155   IFS=$as_save_IFS
11156   test -z "$as_dir" && as_dir=.
11157     for ac_exec_ext in '' $ac_executable_extensions; do
11158   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11159     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
11160     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11161     break 2
11162   fi
11163 done
11164   done
11165 IFS=$as_save_IFS
11166 
11167   ;;
11168 esac
11169 fi
11170 TEE=$ac_cv_path_TEE
11171 if test -n "$TEE"; then
11172   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
11173 $as_echo "$TEE" >&6; }
11174 else
11175   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11176 $as_echo "no" >&6; }
11177 fi
11178 
11179 
11180           if test "x$TEE" = x; then
11181             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11182           fi
11183         else
11184           # Otherwise we believe it is a complete path. Use it as it is.
11185           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
11186 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
11187           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
11188 $as_echo_n "checking for TEE... " >&6; }
11189           if test ! -x "$tool_specified"; then
11190             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11191 $as_echo "not found" >&6; }
11192             as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
11193           fi
11194           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11195 $as_echo "$tool_specified" >&6; }
11196         fi
11197       fi
11198     fi
11199 
11200   fi
11201 
11202 
11203 
11204   if test "x$TEE" = x; then
11205     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
11206   fi
11207 
11208 
11209 
11210 
11211 
11212   # Publish this variable in the help.
11213 
11214 
11215   if [ -z "${TOUCH+x}" ]; then
11216     # The variable is not set by user, try to locate tool using the code snippet
11217     for ac_prog in touch
11218 do
11219   # Extract the first word of "$ac_prog", so it can be a program name with args.
11220 set dummy $ac_prog; ac_word=$2
11221 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11222 $as_echo_n "checking for $ac_word... " >&6; }
11223 if ${ac_cv_path_TOUCH+:} false; then :
11224   $as_echo_n "(cached) " >&6
11225 else
11226   case $TOUCH in
11227   [\\/]* | ?:[\\/]*)
11228   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11229   ;;
11230   *)
11231   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11232 for as_dir in $PATH
11233 do
11234   IFS=$as_save_IFS
11235   test -z "$as_dir" && as_dir=.
11236     for ac_exec_ext in '' $ac_executable_extensions; do
11237   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11238     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11239     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11240     break 2
11241   fi
11242 done
11243   done
11244 IFS=$as_save_IFS
11245 
11246   ;;
11247 esac
11248 fi
11249 TOUCH=$ac_cv_path_TOUCH
11250 if test -n "$TOUCH"; then
11251   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11252 $as_echo "$TOUCH" >&6; }
11253 else
11254   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11255 $as_echo "no" >&6; }
11256 fi
11257 
11258 
11259   test -n "$TOUCH" && break
11260 done
11261 
11262   else
11263     # The variable is set, but is it from the command line or the environment?
11264 
11265     # Try to remove the string !TOUCH! from our list.
11266     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
11267     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11268       # If it failed, the variable was not from the command line. Ignore it,
11269       # but warn the user (except for BASH, which is always set by the calling BASH).
11270       if test "xTOUCH" != xBASH; then
11271         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
11272 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
11273       fi
11274       # Try to locate tool using the code snippet
11275       for ac_prog in touch
11276 do
11277   # Extract the first word of "$ac_prog", so it can be a program name with args.
11278 set dummy $ac_prog; ac_word=$2
11279 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11280 $as_echo_n "checking for $ac_word... " >&6; }
11281 if ${ac_cv_path_TOUCH+:} false; then :
11282   $as_echo_n "(cached) " >&6
11283 else
11284   case $TOUCH in
11285   [\\/]* | ?:[\\/]*)
11286   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11287   ;;
11288   *)
11289   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11290 for as_dir in $PATH
11291 do
11292   IFS=$as_save_IFS
11293   test -z "$as_dir" && as_dir=.
11294     for ac_exec_ext in '' $ac_executable_extensions; do
11295   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11296     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11297     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11298     break 2
11299   fi
11300 done
11301   done
11302 IFS=$as_save_IFS
11303 
11304   ;;
11305 esac
11306 fi
11307 TOUCH=$ac_cv_path_TOUCH
11308 if test -n "$TOUCH"; then
11309   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11310 $as_echo "$TOUCH" >&6; }
11311 else
11312   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11313 $as_echo "no" >&6; }
11314 fi
11315 
11316 
11317   test -n "$TOUCH" && break
11318 done
11319 
11320     else
11321       # If it succeeded, then it was overridden by the user. We will use it
11322       # for the tool.
11323 
11324       # First remove it from the list of overridden variables, so we can test
11325       # for unknown variables in the end.
11326       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11327 
11328       # Check if we try to supply an empty value
11329       if test "x$TOUCH" = x; then
11330         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
11331 $as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
11332         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11333 $as_echo_n "checking for TOUCH... " >&6; }
11334         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11335 $as_echo "disabled" >&6; }
11336       else
11337         # Check if the provided tool contains a complete path.
11338         tool_specified="$TOUCH"
11339         tool_basename="${tool_specified##*/}"
11340         if test "x$tool_basename" = "x$tool_specified"; then
11341           # A command without a complete path is provided, search $PATH.
11342           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
11343 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
11344           # Extract the first word of "$tool_basename", so it can be a program name with args.
11345 set dummy $tool_basename; ac_word=$2
11346 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11347 $as_echo_n "checking for $ac_word... " >&6; }
11348 if ${ac_cv_path_TOUCH+:} false; then :
11349   $as_echo_n "(cached) " >&6
11350 else
11351   case $TOUCH in
11352   [\\/]* | ?:[\\/]*)
11353   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
11354   ;;
11355   *)
11356   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11357 for as_dir in $PATH
11358 do
11359   IFS=$as_save_IFS
11360   test -z "$as_dir" && as_dir=.
11361     for ac_exec_ext in '' $ac_executable_extensions; do
11362   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11363     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
11364     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11365     break 2
11366   fi
11367 done
11368   done
11369 IFS=$as_save_IFS
11370 
11371   ;;
11372 esac
11373 fi
11374 TOUCH=$ac_cv_path_TOUCH
11375 if test -n "$TOUCH"; then
11376   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
11377 $as_echo "$TOUCH" >&6; }
11378 else
11379   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11380 $as_echo "no" >&6; }
11381 fi
11382 
11383 
11384           if test "x$TOUCH" = x; then
11385             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11386           fi
11387         else
11388           # Otherwise we believe it is a complete path. Use it as it is.
11389           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
11390 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
11391           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
11392 $as_echo_n "checking for TOUCH... " >&6; }
11393           if test ! -x "$tool_specified"; then
11394             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11395 $as_echo "not found" >&6; }
11396             as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
11397           fi
11398           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11399 $as_echo "$tool_specified" >&6; }
11400         fi
11401       fi
11402     fi
11403 
11404   fi
11405 
11406 
11407 
11408   if test "x$TOUCH" = x; then
11409     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
11410   fi
11411 
11412 
11413 
11414 
11415 
11416   # Publish this variable in the help.
11417 
11418 
11419   if [ -z "${TR+x}" ]; then
11420     # The variable is not set by user, try to locate tool using the code snippet
11421     for ac_prog in tr
11422 do
11423   # Extract the first word of "$ac_prog", so it can be a program name with args.
11424 set dummy $ac_prog; ac_word=$2
11425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11426 $as_echo_n "checking for $ac_word... " >&6; }
11427 if ${ac_cv_path_TR+:} false; then :
11428   $as_echo_n "(cached) " >&6
11429 else
11430   case $TR in
11431   [\\/]* | ?:[\\/]*)
11432   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11433   ;;
11434   *)
11435   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11436 for as_dir in $PATH
11437 do
11438   IFS=$as_save_IFS
11439   test -z "$as_dir" && as_dir=.
11440     for ac_exec_ext in '' $ac_executable_extensions; do
11441   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11442     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11443     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11444     break 2
11445   fi
11446 done
11447   done
11448 IFS=$as_save_IFS
11449 
11450   ;;
11451 esac
11452 fi
11453 TR=$ac_cv_path_TR
11454 if test -n "$TR"; then
11455   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11456 $as_echo "$TR" >&6; }
11457 else
11458   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11459 $as_echo "no" >&6; }
11460 fi
11461 
11462 
11463   test -n "$TR" && break
11464 done
11465 
11466   else
11467     # The variable is set, but is it from the command line or the environment?
11468 
11469     # Try to remove the string !TR! from our list.
11470     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
11471     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11472       # If it failed, the variable was not from the command line. Ignore it,
11473       # but warn the user (except for BASH, which is always set by the calling BASH).
11474       if test "xTR" != xBASH; then
11475         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
11476 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
11477       fi
11478       # Try to locate tool using the code snippet
11479       for ac_prog in tr
11480 do
11481   # Extract the first word of "$ac_prog", so it can be a program name with args.
11482 set dummy $ac_prog; ac_word=$2
11483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11484 $as_echo_n "checking for $ac_word... " >&6; }
11485 if ${ac_cv_path_TR+:} false; then :
11486   $as_echo_n "(cached) " >&6
11487 else
11488   case $TR in
11489   [\\/]* | ?:[\\/]*)
11490   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11491   ;;
11492   *)
11493   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11494 for as_dir in $PATH
11495 do
11496   IFS=$as_save_IFS
11497   test -z "$as_dir" && as_dir=.
11498     for ac_exec_ext in '' $ac_executable_extensions; do
11499   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11500     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11501     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11502     break 2
11503   fi
11504 done
11505   done
11506 IFS=$as_save_IFS
11507 
11508   ;;
11509 esac
11510 fi
11511 TR=$ac_cv_path_TR
11512 if test -n "$TR"; then
11513   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11514 $as_echo "$TR" >&6; }
11515 else
11516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11517 $as_echo "no" >&6; }
11518 fi
11519 
11520 
11521   test -n "$TR" && break
11522 done
11523 
11524     else
11525       # If it succeeded, then it was overridden by the user. We will use it
11526       # for the tool.
11527 
11528       # First remove it from the list of overridden variables, so we can test
11529       # for unknown variables in the end.
11530       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11531 
11532       # Check if we try to supply an empty value
11533       if test "x$TR" = x; then
11534         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
11535 $as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
11536         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11537 $as_echo_n "checking for TR... " >&6; }
11538         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11539 $as_echo "disabled" >&6; }
11540       else
11541         # Check if the provided tool contains a complete path.
11542         tool_specified="$TR"
11543         tool_basename="${tool_specified##*/}"
11544         if test "x$tool_basename" = "x$tool_specified"; then
11545           # A command without a complete path is provided, search $PATH.
11546           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
11547 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
11548           # Extract the first word of "$tool_basename", so it can be a program name with args.
11549 set dummy $tool_basename; ac_word=$2
11550 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11551 $as_echo_n "checking for $ac_word... " >&6; }
11552 if ${ac_cv_path_TR+:} false; then :
11553   $as_echo_n "(cached) " >&6
11554 else
11555   case $TR in
11556   [\\/]* | ?:[\\/]*)
11557   ac_cv_path_TR="$TR" # Let the user override the test with a path.
11558   ;;
11559   *)
11560   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11561 for as_dir in $PATH
11562 do
11563   IFS=$as_save_IFS
11564   test -z "$as_dir" && as_dir=.
11565     for ac_exec_ext in '' $ac_executable_extensions; do
11566   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11567     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
11568     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11569     break 2
11570   fi
11571 done
11572   done
11573 IFS=$as_save_IFS
11574 
11575   ;;
11576 esac
11577 fi
11578 TR=$ac_cv_path_TR
11579 if test -n "$TR"; then
11580   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
11581 $as_echo "$TR" >&6; }
11582 else
11583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11584 $as_echo "no" >&6; }
11585 fi
11586 
11587 
11588           if test "x$TR" = x; then
11589             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11590           fi
11591         else
11592           # Otherwise we believe it is a complete path. Use it as it is.
11593           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
11594 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
11595           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
11596 $as_echo_n "checking for TR... " >&6; }
11597           if test ! -x "$tool_specified"; then
11598             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11599 $as_echo "not found" >&6; }
11600             as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
11601           fi
11602           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11603 $as_echo "$tool_specified" >&6; }
11604         fi
11605       fi
11606     fi
11607 
11608   fi
11609 
11610 
11611 
11612   if test "x$TR" = x; then
11613     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
11614   fi
11615 
11616 
11617 
11618 
11619 
11620   # Publish this variable in the help.
11621 
11622 
11623   if [ -z "${UNAME+x}" ]; then
11624     # The variable is not set by user, try to locate tool using the code snippet
11625     for ac_prog in uname
11626 do
11627   # Extract the first word of "$ac_prog", so it can be a program name with args.
11628 set dummy $ac_prog; ac_word=$2
11629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11630 $as_echo_n "checking for $ac_word... " >&6; }
11631 if ${ac_cv_path_UNAME+:} false; then :
11632   $as_echo_n "(cached) " >&6
11633 else
11634   case $UNAME in
11635   [\\/]* | ?:[\\/]*)
11636   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11637   ;;
11638   *)
11639   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11640 for as_dir in $PATH
11641 do
11642   IFS=$as_save_IFS
11643   test -z "$as_dir" && as_dir=.
11644     for ac_exec_ext in '' $ac_executable_extensions; do
11645   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11646     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11647     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11648     break 2
11649   fi
11650 done
11651   done
11652 IFS=$as_save_IFS
11653 
11654   ;;
11655 esac
11656 fi
11657 UNAME=$ac_cv_path_UNAME
11658 if test -n "$UNAME"; then
11659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11660 $as_echo "$UNAME" >&6; }
11661 else
11662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11663 $as_echo "no" >&6; }
11664 fi
11665 
11666 
11667   test -n "$UNAME" && break
11668 done
11669 
11670   else
11671     # The variable is set, but is it from the command line or the environment?
11672 
11673     # Try to remove the string !UNAME! from our list.
11674     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
11675     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11676       # If it failed, the variable was not from the command line. Ignore it,
11677       # but warn the user (except for BASH, which is always set by the calling BASH).
11678       if test "xUNAME" != xBASH; then
11679         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
11680 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
11681       fi
11682       # Try to locate tool using the code snippet
11683       for ac_prog in uname
11684 do
11685   # Extract the first word of "$ac_prog", so it can be a program name with args.
11686 set dummy $ac_prog; ac_word=$2
11687 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11688 $as_echo_n "checking for $ac_word... " >&6; }
11689 if ${ac_cv_path_UNAME+:} false; then :
11690   $as_echo_n "(cached) " >&6
11691 else
11692   case $UNAME in
11693   [\\/]* | ?:[\\/]*)
11694   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11695   ;;
11696   *)
11697   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11698 for as_dir in $PATH
11699 do
11700   IFS=$as_save_IFS
11701   test -z "$as_dir" && as_dir=.
11702     for ac_exec_ext in '' $ac_executable_extensions; do
11703   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11704     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11705     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11706     break 2
11707   fi
11708 done
11709   done
11710 IFS=$as_save_IFS
11711 
11712   ;;
11713 esac
11714 fi
11715 UNAME=$ac_cv_path_UNAME
11716 if test -n "$UNAME"; then
11717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11718 $as_echo "$UNAME" >&6; }
11719 else
11720   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11721 $as_echo "no" >&6; }
11722 fi
11723 
11724 
11725   test -n "$UNAME" && break
11726 done
11727 
11728     else
11729       # If it succeeded, then it was overridden by the user. We will use it
11730       # for the tool.
11731 
11732       # First remove it from the list of overridden variables, so we can test
11733       # for unknown variables in the end.
11734       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11735 
11736       # Check if we try to supply an empty value
11737       if test "x$UNAME" = x; then
11738         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
11739 $as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
11740         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11741 $as_echo_n "checking for UNAME... " >&6; }
11742         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11743 $as_echo "disabled" >&6; }
11744       else
11745         # Check if the provided tool contains a complete path.
11746         tool_specified="$UNAME"
11747         tool_basename="${tool_specified##*/}"
11748         if test "x$tool_basename" = "x$tool_specified"; then
11749           # A command without a complete path is provided, search $PATH.
11750           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
11751 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
11752           # Extract the first word of "$tool_basename", so it can be a program name with args.
11753 set dummy $tool_basename; ac_word=$2
11754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11755 $as_echo_n "checking for $ac_word... " >&6; }
11756 if ${ac_cv_path_UNAME+:} false; then :
11757   $as_echo_n "(cached) " >&6
11758 else
11759   case $UNAME in
11760   [\\/]* | ?:[\\/]*)
11761   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
11762   ;;
11763   *)
11764   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11765 for as_dir in $PATH
11766 do
11767   IFS=$as_save_IFS
11768   test -z "$as_dir" && as_dir=.
11769     for ac_exec_ext in '' $ac_executable_extensions; do
11770   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11771     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
11772     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11773     break 2
11774   fi
11775 done
11776   done
11777 IFS=$as_save_IFS
11778 
11779   ;;
11780 esac
11781 fi
11782 UNAME=$ac_cv_path_UNAME
11783 if test -n "$UNAME"; then
11784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
11785 $as_echo "$UNAME" >&6; }
11786 else
11787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11788 $as_echo "no" >&6; }
11789 fi
11790 
11791 
11792           if test "x$UNAME" = x; then
11793             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11794           fi
11795         else
11796           # Otherwise we believe it is a complete path. Use it as it is.
11797           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
11798 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
11799           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
11800 $as_echo_n "checking for UNAME... " >&6; }
11801           if test ! -x "$tool_specified"; then
11802             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11803 $as_echo "not found" >&6; }
11804             as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
11805           fi
11806           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11807 $as_echo "$tool_specified" >&6; }
11808         fi
11809       fi
11810     fi
11811 
11812   fi
11813 
11814 
11815 
11816   if test "x$UNAME" = x; then
11817     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
11818   fi
11819 
11820 
11821 
11822 
11823 
11824   # Publish this variable in the help.
11825 
11826 
11827   if [ -z "${UNIQ+x}" ]; then
11828     # The variable is not set by user, try to locate tool using the code snippet
11829     for ac_prog in uniq
11830 do
11831   # Extract the first word of "$ac_prog", so it can be a program name with args.
11832 set dummy $ac_prog; ac_word=$2
11833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11834 $as_echo_n "checking for $ac_word... " >&6; }
11835 if ${ac_cv_path_UNIQ+:} false; then :
11836   $as_echo_n "(cached) " >&6
11837 else
11838   case $UNIQ in
11839   [\\/]* | ?:[\\/]*)
11840   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11841   ;;
11842   *)
11843   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11844 for as_dir in $PATH
11845 do
11846   IFS=$as_save_IFS
11847   test -z "$as_dir" && as_dir=.
11848     for ac_exec_ext in '' $ac_executable_extensions; do
11849   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11850     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11851     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11852     break 2
11853   fi
11854 done
11855   done
11856 IFS=$as_save_IFS
11857 
11858   ;;
11859 esac
11860 fi
11861 UNIQ=$ac_cv_path_UNIQ
11862 if test -n "$UNIQ"; then
11863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11864 $as_echo "$UNIQ" >&6; }
11865 else
11866   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11867 $as_echo "no" >&6; }
11868 fi
11869 
11870 
11871   test -n "$UNIQ" && break
11872 done
11873 
11874   else
11875     # The variable is set, but is it from the command line or the environment?
11876 
11877     # Try to remove the string !UNIQ! from our list.
11878     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
11879     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11880       # If it failed, the variable was not from the command line. Ignore it,
11881       # but warn the user (except for BASH, which is always set by the calling BASH).
11882       if test "xUNIQ" != xBASH; then
11883         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
11884 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
11885       fi
11886       # Try to locate tool using the code snippet
11887       for ac_prog in uniq
11888 do
11889   # Extract the first word of "$ac_prog", so it can be a program name with args.
11890 set dummy $ac_prog; ac_word=$2
11891 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11892 $as_echo_n "checking for $ac_word... " >&6; }
11893 if ${ac_cv_path_UNIQ+:} false; then :
11894   $as_echo_n "(cached) " >&6
11895 else
11896   case $UNIQ in
11897   [\\/]* | ?:[\\/]*)
11898   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11899   ;;
11900   *)
11901   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11902 for as_dir in $PATH
11903 do
11904   IFS=$as_save_IFS
11905   test -z "$as_dir" && as_dir=.
11906     for ac_exec_ext in '' $ac_executable_extensions; do
11907   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11908     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11909     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11910     break 2
11911   fi
11912 done
11913   done
11914 IFS=$as_save_IFS
11915 
11916   ;;
11917 esac
11918 fi
11919 UNIQ=$ac_cv_path_UNIQ
11920 if test -n "$UNIQ"; then
11921   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11922 $as_echo "$UNIQ" >&6; }
11923 else
11924   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11925 $as_echo "no" >&6; }
11926 fi
11927 
11928 
11929   test -n "$UNIQ" && break
11930 done
11931 
11932     else
11933       # If it succeeded, then it was overridden by the user. We will use it
11934       # for the tool.
11935 
11936       # First remove it from the list of overridden variables, so we can test
11937       # for unknown variables in the end.
11938       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11939 
11940       # Check if we try to supply an empty value
11941       if test "x$UNIQ" = x; then
11942         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
11943 $as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
11944         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
11945 $as_echo_n "checking for UNIQ... " >&6; }
11946         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
11947 $as_echo "disabled" >&6; }
11948       else
11949         # Check if the provided tool contains a complete path.
11950         tool_specified="$UNIQ"
11951         tool_basename="${tool_specified##*/}"
11952         if test "x$tool_basename" = "x$tool_specified"; then
11953           # A command without a complete path is provided, search $PATH.
11954           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
11955 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
11956           # Extract the first word of "$tool_basename", so it can be a program name with args.
11957 set dummy $tool_basename; ac_word=$2
11958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11959 $as_echo_n "checking for $ac_word... " >&6; }
11960 if ${ac_cv_path_UNIQ+:} false; then :
11961   $as_echo_n "(cached) " >&6
11962 else
11963   case $UNIQ in
11964   [\\/]* | ?:[\\/]*)
11965   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
11966   ;;
11967   *)
11968   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11969 for as_dir in $PATH
11970 do
11971   IFS=$as_save_IFS
11972   test -z "$as_dir" && as_dir=.
11973     for ac_exec_ext in '' $ac_executable_extensions; do
11974   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11975     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
11976     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11977     break 2
11978   fi
11979 done
11980   done
11981 IFS=$as_save_IFS
11982 
11983   ;;
11984 esac
11985 fi
11986 UNIQ=$ac_cv_path_UNIQ
11987 if test -n "$UNIQ"; then
11988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
11989 $as_echo "$UNIQ" >&6; }
11990 else
11991   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11992 $as_echo "no" >&6; }
11993 fi
11994 
11995 
11996           if test "x$UNIQ" = x; then
11997             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11998           fi
11999         else
12000           # Otherwise we believe it is a complete path. Use it as it is.
12001           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
12002 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
12003           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
12004 $as_echo_n "checking for UNIQ... " >&6; }
12005           if test ! -x "$tool_specified"; then
12006             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12007 $as_echo "not found" >&6; }
12008             as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
12009           fi
12010           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12011 $as_echo "$tool_specified" >&6; }
12012         fi
12013       fi
12014     fi
12015 
12016   fi
12017 
12018 
12019 
12020   if test "x$UNIQ" = x; then
12021     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
12022   fi
12023 
12024 
12025 
12026 
12027 
12028   # Publish this variable in the help.
12029 
12030 
12031   if [ -z "${WC+x}" ]; then
12032     # The variable is not set by user, try to locate tool using the code snippet
12033     for ac_prog in wc
12034 do
12035   # Extract the first word of "$ac_prog", so it can be a program name with args.
12036 set dummy $ac_prog; ac_word=$2
12037 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12038 $as_echo_n "checking for $ac_word... " >&6; }
12039 if ${ac_cv_path_WC+:} false; then :
12040   $as_echo_n "(cached) " >&6
12041 else
12042   case $WC in
12043   [\\/]* | ?:[\\/]*)
12044   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12045   ;;
12046   *)
12047   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12048 for as_dir in $PATH
12049 do
12050   IFS=$as_save_IFS
12051   test -z "$as_dir" && as_dir=.
12052     for ac_exec_ext in '' $ac_executable_extensions; do
12053   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12054     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12055     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12056     break 2
12057   fi
12058 done
12059   done
12060 IFS=$as_save_IFS
12061 
12062   ;;
12063 esac
12064 fi
12065 WC=$ac_cv_path_WC
12066 if test -n "$WC"; then
12067   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12068 $as_echo "$WC" >&6; }
12069 else
12070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12071 $as_echo "no" >&6; }
12072 fi
12073 
12074 
12075   test -n "$WC" && break
12076 done
12077 
12078   else
12079     # The variable is set, but is it from the command line or the environment?
12080 
12081     # Try to remove the string !WC! from our list.
12082     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
12083     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12084       # If it failed, the variable was not from the command line. Ignore it,
12085       # but warn the user (except for BASH, which is always set by the calling BASH).
12086       if test "xWC" != xBASH; then
12087         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
12088 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
12089       fi
12090       # Try to locate tool using the code snippet
12091       for ac_prog in wc
12092 do
12093   # Extract the first word of "$ac_prog", so it can be a program name with args.
12094 set dummy $ac_prog; ac_word=$2
12095 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12096 $as_echo_n "checking for $ac_word... " >&6; }
12097 if ${ac_cv_path_WC+:} false; then :
12098   $as_echo_n "(cached) " >&6
12099 else
12100   case $WC in
12101   [\\/]* | ?:[\\/]*)
12102   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12103   ;;
12104   *)
12105   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12106 for as_dir in $PATH
12107 do
12108   IFS=$as_save_IFS
12109   test -z "$as_dir" && as_dir=.
12110     for ac_exec_ext in '' $ac_executable_extensions; do
12111   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12112     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12113     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12114     break 2
12115   fi
12116 done
12117   done
12118 IFS=$as_save_IFS
12119 
12120   ;;
12121 esac
12122 fi
12123 WC=$ac_cv_path_WC
12124 if test -n "$WC"; then
12125   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12126 $as_echo "$WC" >&6; }
12127 else
12128   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12129 $as_echo "no" >&6; }
12130 fi
12131 
12132 
12133   test -n "$WC" && break
12134 done
12135 
12136     else
12137       # If it succeeded, then it was overridden by the user. We will use it
12138       # for the tool.
12139 
12140       # First remove it from the list of overridden variables, so we can test
12141       # for unknown variables in the end.
12142       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12143 
12144       # Check if we try to supply an empty value
12145       if test "x$WC" = x; then
12146         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
12147 $as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
12148         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12149 $as_echo_n "checking for WC... " >&6; }
12150         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12151 $as_echo "disabled" >&6; }
12152       else
12153         # Check if the provided tool contains a complete path.
12154         tool_specified="$WC"
12155         tool_basename="${tool_specified##*/}"
12156         if test "x$tool_basename" = "x$tool_specified"; then
12157           # A command without a complete path is provided, search $PATH.
12158           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
12159 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
12160           # Extract the first word of "$tool_basename", so it can be a program name with args.
12161 set dummy $tool_basename; ac_word=$2
12162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12163 $as_echo_n "checking for $ac_word... " >&6; }
12164 if ${ac_cv_path_WC+:} false; then :
12165   $as_echo_n "(cached) " >&6
12166 else
12167   case $WC in
12168   [\\/]* | ?:[\\/]*)
12169   ac_cv_path_WC="$WC" # Let the user override the test with a path.
12170   ;;
12171   *)
12172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12173 for as_dir in $PATH
12174 do
12175   IFS=$as_save_IFS
12176   test -z "$as_dir" && as_dir=.
12177     for ac_exec_ext in '' $ac_executable_extensions; do
12178   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12179     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
12180     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12181     break 2
12182   fi
12183 done
12184   done
12185 IFS=$as_save_IFS
12186 
12187   ;;
12188 esac
12189 fi
12190 WC=$ac_cv_path_WC
12191 if test -n "$WC"; then
12192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
12193 $as_echo "$WC" >&6; }
12194 else
12195   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12196 $as_echo "no" >&6; }
12197 fi
12198 
12199 
12200           if test "x$WC" = x; then
12201             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12202           fi
12203         else
12204           # Otherwise we believe it is a complete path. Use it as it is.
12205           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
12206 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
12207           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
12208 $as_echo_n "checking for WC... " >&6; }
12209           if test ! -x "$tool_specified"; then
12210             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12211 $as_echo "not found" >&6; }
12212             as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
12213           fi
12214           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12215 $as_echo "$tool_specified" >&6; }
12216         fi
12217       fi
12218     fi
12219 
12220   fi
12221 
12222 
12223 
12224   if test "x$WC" = x; then
12225     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
12226   fi
12227 
12228 
12229 
12230 
12231 
12232   # Publish this variable in the help.
12233 
12234 
12235   if [ -z "${WHICH+x}" ]; then
12236     # The variable is not set by user, try to locate tool using the code snippet
12237     for ac_prog in which
12238 do
12239   # Extract the first word of "$ac_prog", so it can be a program name with args.
12240 set dummy $ac_prog; ac_word=$2
12241 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12242 $as_echo_n "checking for $ac_word... " >&6; }
12243 if ${ac_cv_path_WHICH+:} false; then :
12244   $as_echo_n "(cached) " >&6
12245 else
12246   case $WHICH in
12247   [\\/]* | ?:[\\/]*)
12248   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12249   ;;
12250   *)
12251   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12252 for as_dir in $PATH
12253 do
12254   IFS=$as_save_IFS
12255   test -z "$as_dir" && as_dir=.
12256     for ac_exec_ext in '' $ac_executable_extensions; do
12257   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12258     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12259     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12260     break 2
12261   fi
12262 done
12263   done
12264 IFS=$as_save_IFS
12265 
12266   ;;
12267 esac
12268 fi
12269 WHICH=$ac_cv_path_WHICH
12270 if test -n "$WHICH"; then
12271   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12272 $as_echo "$WHICH" >&6; }
12273 else
12274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12275 $as_echo "no" >&6; }
12276 fi
12277 
12278 
12279   test -n "$WHICH" && break
12280 done
12281 
12282   else
12283     # The variable is set, but is it from the command line or the environment?
12284 
12285     # Try to remove the string !WHICH! from our list.
12286     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
12287     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12288       # If it failed, the variable was not from the command line. Ignore it,
12289       # but warn the user (except for BASH, which is always set by the calling BASH).
12290       if test "xWHICH" != xBASH; then
12291         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
12292 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
12293       fi
12294       # Try to locate tool using the code snippet
12295       for ac_prog in which
12296 do
12297   # Extract the first word of "$ac_prog", so it can be a program name with args.
12298 set dummy $ac_prog; ac_word=$2
12299 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12300 $as_echo_n "checking for $ac_word... " >&6; }
12301 if ${ac_cv_path_WHICH+:} false; then :
12302   $as_echo_n "(cached) " >&6
12303 else
12304   case $WHICH in
12305   [\\/]* | ?:[\\/]*)
12306   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12307   ;;
12308   *)
12309   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12310 for as_dir in $PATH
12311 do
12312   IFS=$as_save_IFS
12313   test -z "$as_dir" && as_dir=.
12314     for ac_exec_ext in '' $ac_executable_extensions; do
12315   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12316     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12317     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12318     break 2
12319   fi
12320 done
12321   done
12322 IFS=$as_save_IFS
12323 
12324   ;;
12325 esac
12326 fi
12327 WHICH=$ac_cv_path_WHICH
12328 if test -n "$WHICH"; then
12329   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12330 $as_echo "$WHICH" >&6; }
12331 else
12332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12333 $as_echo "no" >&6; }
12334 fi
12335 
12336 
12337   test -n "$WHICH" && break
12338 done
12339 
12340     else
12341       # If it succeeded, then it was overridden by the user. We will use it
12342       # for the tool.
12343 
12344       # First remove it from the list of overridden variables, so we can test
12345       # for unknown variables in the end.
12346       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12347 
12348       # Check if we try to supply an empty value
12349       if test "x$WHICH" = x; then
12350         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
12351 $as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
12352         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12353 $as_echo_n "checking for WHICH... " >&6; }
12354         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12355 $as_echo "disabled" >&6; }
12356       else
12357         # Check if the provided tool contains a complete path.
12358         tool_specified="$WHICH"
12359         tool_basename="${tool_specified##*/}"
12360         if test "x$tool_basename" = "x$tool_specified"; then
12361           # A command without a complete path is provided, search $PATH.
12362           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
12363 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
12364           # Extract the first word of "$tool_basename", so it can be a program name with args.
12365 set dummy $tool_basename; ac_word=$2
12366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12367 $as_echo_n "checking for $ac_word... " >&6; }
12368 if ${ac_cv_path_WHICH+:} false; then :
12369   $as_echo_n "(cached) " >&6
12370 else
12371   case $WHICH in
12372   [\\/]* | ?:[\\/]*)
12373   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
12374   ;;
12375   *)
12376   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12377 for as_dir in $PATH
12378 do
12379   IFS=$as_save_IFS
12380   test -z "$as_dir" && as_dir=.
12381     for ac_exec_ext in '' $ac_executable_extensions; do
12382   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12383     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
12384     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12385     break 2
12386   fi
12387 done
12388   done
12389 IFS=$as_save_IFS
12390 
12391   ;;
12392 esac
12393 fi
12394 WHICH=$ac_cv_path_WHICH
12395 if test -n "$WHICH"; then
12396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
12397 $as_echo "$WHICH" >&6; }
12398 else
12399   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12400 $as_echo "no" >&6; }
12401 fi
12402 
12403 
12404           if test "x$WHICH" = x; then
12405             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12406           fi
12407         else
12408           # Otherwise we believe it is a complete path. Use it as it is.
12409           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
12410 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
12411           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
12412 $as_echo_n "checking for WHICH... " >&6; }
12413           if test ! -x "$tool_specified"; then
12414             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12415 $as_echo "not found" >&6; }
12416             as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
12417           fi
12418           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12419 $as_echo "$tool_specified" >&6; }
12420         fi
12421       fi
12422     fi
12423 
12424   fi
12425 
12426 
12427 
12428   if test "x$WHICH" = x; then
12429     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
12430   fi
12431 
12432 
12433 
12434 
12435 
12436   # Publish this variable in the help.
12437 
12438 
12439   if [ -z "${XARGS+x}" ]; then
12440     # The variable is not set by user, try to locate tool using the code snippet
12441     for ac_prog in xargs
12442 do
12443   # Extract the first word of "$ac_prog", so it can be a program name with args.
12444 set dummy $ac_prog; ac_word=$2
12445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12446 $as_echo_n "checking for $ac_word... " >&6; }
12447 if ${ac_cv_path_XARGS+:} false; then :
12448   $as_echo_n "(cached) " >&6
12449 else
12450   case $XARGS in
12451   [\\/]* | ?:[\\/]*)
12452   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12453   ;;
12454   *)
12455   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12456 for as_dir in $PATH
12457 do
12458   IFS=$as_save_IFS
12459   test -z "$as_dir" && as_dir=.
12460     for ac_exec_ext in '' $ac_executable_extensions; do
12461   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12462     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12463     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12464     break 2
12465   fi
12466 done
12467   done
12468 IFS=$as_save_IFS
12469 
12470   ;;
12471 esac
12472 fi
12473 XARGS=$ac_cv_path_XARGS
12474 if test -n "$XARGS"; then
12475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12476 $as_echo "$XARGS" >&6; }
12477 else
12478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12479 $as_echo "no" >&6; }
12480 fi
12481 
12482 
12483   test -n "$XARGS" && break
12484 done
12485 
12486   else
12487     # The variable is set, but is it from the command line or the environment?
12488 
12489     # Try to remove the string !XARGS! from our list.
12490     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
12491     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12492       # If it failed, the variable was not from the command line. Ignore it,
12493       # but warn the user (except for BASH, which is always set by the calling BASH).
12494       if test "xXARGS" != xBASH; then
12495         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
12496 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
12497       fi
12498       # Try to locate tool using the code snippet
12499       for ac_prog in xargs
12500 do
12501   # Extract the first word of "$ac_prog", so it can be a program name with args.
12502 set dummy $ac_prog; ac_word=$2
12503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12504 $as_echo_n "checking for $ac_word... " >&6; }
12505 if ${ac_cv_path_XARGS+:} false; then :
12506   $as_echo_n "(cached) " >&6
12507 else
12508   case $XARGS in
12509   [\\/]* | ?:[\\/]*)
12510   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12511   ;;
12512   *)
12513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12514 for as_dir in $PATH
12515 do
12516   IFS=$as_save_IFS
12517   test -z "$as_dir" && as_dir=.
12518     for ac_exec_ext in '' $ac_executable_extensions; do
12519   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12520     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12521     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12522     break 2
12523   fi
12524 done
12525   done
12526 IFS=$as_save_IFS
12527 
12528   ;;
12529 esac
12530 fi
12531 XARGS=$ac_cv_path_XARGS
12532 if test -n "$XARGS"; then
12533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12534 $as_echo "$XARGS" >&6; }
12535 else
12536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12537 $as_echo "no" >&6; }
12538 fi
12539 
12540 
12541   test -n "$XARGS" && break
12542 done
12543 
12544     else
12545       # If it succeeded, then it was overridden by the user. We will use it
12546       # for the tool.
12547 
12548       # First remove it from the list of overridden variables, so we can test
12549       # for unknown variables in the end.
12550       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12551 
12552       # Check if we try to supply an empty value
12553       if test "x$XARGS" = x; then
12554         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
12555 $as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
12556         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12557 $as_echo_n "checking for XARGS... " >&6; }
12558         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12559 $as_echo "disabled" >&6; }
12560       else
12561         # Check if the provided tool contains a complete path.
12562         tool_specified="$XARGS"
12563         tool_basename="${tool_specified##*/}"
12564         if test "x$tool_basename" = "x$tool_specified"; then
12565           # A command without a complete path is provided, search $PATH.
12566           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
12567 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
12568           # Extract the first word of "$tool_basename", so it can be a program name with args.
12569 set dummy $tool_basename; ac_word=$2
12570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12571 $as_echo_n "checking for $ac_word... " >&6; }
12572 if ${ac_cv_path_XARGS+:} false; then :
12573   $as_echo_n "(cached) " >&6
12574 else
12575   case $XARGS in
12576   [\\/]* | ?:[\\/]*)
12577   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
12578   ;;
12579   *)
12580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12581 for as_dir in $PATH
12582 do
12583   IFS=$as_save_IFS
12584   test -z "$as_dir" && as_dir=.
12585     for ac_exec_ext in '' $ac_executable_extensions; do
12586   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12587     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
12588     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12589     break 2
12590   fi
12591 done
12592   done
12593 IFS=$as_save_IFS
12594 
12595   ;;
12596 esac
12597 fi
12598 XARGS=$ac_cv_path_XARGS
12599 if test -n "$XARGS"; then
12600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
12601 $as_echo "$XARGS" >&6; }
12602 else
12603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12604 $as_echo "no" >&6; }
12605 fi
12606 
12607 
12608           if test "x$XARGS" = x; then
12609             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12610           fi
12611         else
12612           # Otherwise we believe it is a complete path. Use it as it is.
12613           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
12614 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
12615           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
12616 $as_echo_n "checking for XARGS... " >&6; }
12617           if test ! -x "$tool_specified"; then
12618             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12619 $as_echo "not found" >&6; }
12620             as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
12621           fi
12622           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12623 $as_echo "$tool_specified" >&6; }
12624         fi
12625       fi
12626     fi
12627 
12628   fi
12629 
12630 
12631 
12632   if test "x$XARGS" = x; then
12633     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
12634   fi
12635 
12636 
12637 
12638   # Then required tools that require some special treatment.
12639 
12640 
12641   # Publish this variable in the help.
12642 
12643 
12644   if [ -z "${AWK+x}" ]; then
12645     # The variable is not set by user, try to locate tool using the code snippet
12646     for ac_prog in gawk mawk nawk awk
12647 do
12648   # Extract the first word of "$ac_prog", so it can be a program name with args.
12649 set dummy $ac_prog; ac_word=$2
12650 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12651 $as_echo_n "checking for $ac_word... " >&6; }
12652 if ${ac_cv_prog_AWK+:} false; then :
12653   $as_echo_n "(cached) " >&6
12654 else
12655   if test -n "$AWK"; then
12656   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12657 else
12658 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12659 for as_dir in $PATH
12660 do
12661   IFS=$as_save_IFS
12662   test -z "$as_dir" && as_dir=.
12663     for ac_exec_ext in '' $ac_executable_extensions; do
12664   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12665     ac_cv_prog_AWK="$ac_prog"
12666     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12667     break 2
12668   fi
12669 done
12670   done
12671 IFS=$as_save_IFS
12672 
12673 fi
12674 fi
12675 AWK=$ac_cv_prog_AWK
12676 if test -n "$AWK"; then
12677   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12678 $as_echo "$AWK" >&6; }
12679 else
12680   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12681 $as_echo "no" >&6; }
12682 fi
12683 
12684 
12685   test -n "$AWK" && break
12686 done
12687 
12688   else
12689     # The variable is set, but is it from the command line or the environment?
12690 
12691     # Try to remove the string !AWK! from our list.
12692     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
12693     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12694       # If it failed, the variable was not from the command line. Ignore it,
12695       # but warn the user (except for BASH, which is always set by the calling BASH).
12696       if test "xAWK" != xBASH; then
12697         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
12698 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
12699       fi
12700       # Try to locate tool using the code snippet
12701       for ac_prog in gawk mawk nawk awk
12702 do
12703   # Extract the first word of "$ac_prog", so it can be a program name with args.
12704 set dummy $ac_prog; ac_word=$2
12705 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12706 $as_echo_n "checking for $ac_word... " >&6; }
12707 if ${ac_cv_prog_AWK+:} false; then :
12708   $as_echo_n "(cached) " >&6
12709 else
12710   if test -n "$AWK"; then
12711   ac_cv_prog_AWK="$AWK" # Let the user override the test.
12712 else
12713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12714 for as_dir in $PATH
12715 do
12716   IFS=$as_save_IFS
12717   test -z "$as_dir" && as_dir=.
12718     for ac_exec_ext in '' $ac_executable_extensions; do
12719   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12720     ac_cv_prog_AWK="$ac_prog"
12721     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12722     break 2
12723   fi
12724 done
12725   done
12726 IFS=$as_save_IFS
12727 
12728 fi
12729 fi
12730 AWK=$ac_cv_prog_AWK
12731 if test -n "$AWK"; then
12732   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12733 $as_echo "$AWK" >&6; }
12734 else
12735   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12736 $as_echo "no" >&6; }
12737 fi
12738 
12739 
12740   test -n "$AWK" && break
12741 done
12742 
12743     else
12744       # If it succeeded, then it was overridden by the user. We will use it
12745       # for the tool.
12746 
12747       # First remove it from the list of overridden variables, so we can test
12748       # for unknown variables in the end.
12749       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12750 
12751       # Check if we try to supply an empty value
12752       if test "x$AWK" = x; then
12753         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
12754 $as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
12755         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12756 $as_echo_n "checking for AWK... " >&6; }
12757         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12758 $as_echo "disabled" >&6; }
12759       else
12760         # Check if the provided tool contains a complete path.
12761         tool_specified="$AWK"
12762         tool_basename="${tool_specified##*/}"
12763         if test "x$tool_basename" = "x$tool_specified"; then
12764           # A command without a complete path is provided, search $PATH.
12765           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
12766 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
12767           # Extract the first word of "$tool_basename", so it can be a program name with args.
12768 set dummy $tool_basename; ac_word=$2
12769 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12770 $as_echo_n "checking for $ac_word... " >&6; }
12771 if ${ac_cv_path_AWK+:} false; then :
12772   $as_echo_n "(cached) " >&6
12773 else
12774   case $AWK in
12775   [\\/]* | ?:[\\/]*)
12776   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
12777   ;;
12778   *)
12779   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12780 for as_dir in $PATH
12781 do
12782   IFS=$as_save_IFS
12783   test -z "$as_dir" && as_dir=.
12784     for ac_exec_ext in '' $ac_executable_extensions; do
12785   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12786     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
12787     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12788     break 2
12789   fi
12790 done
12791   done
12792 IFS=$as_save_IFS
12793 
12794   ;;
12795 esac
12796 fi
12797 AWK=$ac_cv_path_AWK
12798 if test -n "$AWK"; then
12799   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
12800 $as_echo "$AWK" >&6; }
12801 else
12802   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12803 $as_echo "no" >&6; }
12804 fi
12805 
12806 
12807           if test "x$AWK" = x; then
12808             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12809           fi
12810         else
12811           # Otherwise we believe it is a complete path. Use it as it is.
12812           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
12813 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
12814           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
12815 $as_echo_n "checking for AWK... " >&6; }
12816           if test ! -x "$tool_specified"; then
12817             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12818 $as_echo "not found" >&6; }
12819             as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
12820           fi
12821           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12822 $as_echo "$tool_specified" >&6; }
12823         fi
12824       fi
12825     fi
12826 
12827   fi
12828 
12829 
12830   if test "x$AWK" = x; then
12831     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
12832   fi
12833 
12834 
12835 
12836 
12837   # Publish this variable in the help.
12838 
12839 
12840   if [ -z "${GREP+x}" ]; then
12841     # The variable is not set by user, try to locate tool using the code snippet
12842     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12843 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12844 if ${ac_cv_path_GREP+:} false; then :
12845   $as_echo_n "(cached) " >&6
12846 else
12847   if test -z "$GREP"; then
12848   ac_path_GREP_found=false
12849   # Loop through the user's path and test for each of PROGNAME-LIST
12850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12851 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12852 do
12853   IFS=$as_save_IFS
12854   test -z "$as_dir" && as_dir=.
12855     for ac_prog in grep ggrep; do
12856     for ac_exec_ext in '' $ac_executable_extensions; do
12857       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12858       as_fn_executable_p "$ac_path_GREP" || continue
12859 # Check for GNU ac_path_GREP and select it if it is found.
12860   # Check for GNU $ac_path_GREP
12861 case `"$ac_path_GREP" --version 2>&1` in
12862 *GNU*)
12863   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12864 *)
12865   ac_count=0
12866   $as_echo_n 0123456789 >"conftest.in"
12867   while :
12868   do
12869     cat "conftest.in" "conftest.in" >"conftest.tmp"
12870     mv "conftest.tmp" "conftest.in"
12871     cp "conftest.in" "conftest.nl"
12872     $as_echo 'GREP' >> "conftest.nl"
12873     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12874     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12875     as_fn_arith $ac_count + 1 && ac_count=$as_val
12876     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12877       # Best one so far, save it but keep looking for a better one
12878       ac_cv_path_GREP="$ac_path_GREP"
12879       ac_path_GREP_max=$ac_count
12880     fi
12881     # 10*(2^10) chars as input seems more than enough
12882     test $ac_count -gt 10 && break
12883   done
12884   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12885 esac
12886 
12887       $ac_path_GREP_found && break 3
12888     done
12889   done
12890   done
12891 IFS=$as_save_IFS
12892   if test -z "$ac_cv_path_GREP"; then
12893     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12894   fi
12895 else
12896   ac_cv_path_GREP=$GREP
12897 fi
12898 
12899 fi
12900 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12901 $as_echo "$ac_cv_path_GREP" >&6; }
12902  GREP="$ac_cv_path_GREP"
12903 
12904 
12905   else
12906     # The variable is set, but is it from the command line or the environment?
12907 
12908     # Try to remove the string !GREP! from our list.
12909     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
12910     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12911       # If it failed, the variable was not from the command line. Ignore it,
12912       # but warn the user (except for BASH, which is always set by the calling BASH).
12913       if test "xGREP" != xBASH; then
12914         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
12915 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
12916       fi
12917       # Try to locate tool using the code snippet
12918       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
12919 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
12920 if ${ac_cv_path_GREP+:} false; then :
12921   $as_echo_n "(cached) " >&6
12922 else
12923   if test -z "$GREP"; then
12924   ac_path_GREP_found=false
12925   # Loop through the user's path and test for each of PROGNAME-LIST
12926   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12927 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12928 do
12929   IFS=$as_save_IFS
12930   test -z "$as_dir" && as_dir=.
12931     for ac_prog in grep ggrep; do
12932     for ac_exec_ext in '' $ac_executable_extensions; do
12933       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
12934       as_fn_executable_p "$ac_path_GREP" || continue
12935 # Check for GNU ac_path_GREP and select it if it is found.
12936   # Check for GNU $ac_path_GREP
12937 case `"$ac_path_GREP" --version 2>&1` in
12938 *GNU*)
12939   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
12940 *)
12941   ac_count=0
12942   $as_echo_n 0123456789 >"conftest.in"
12943   while :
12944   do
12945     cat "conftest.in" "conftest.in" >"conftest.tmp"
12946     mv "conftest.tmp" "conftest.in"
12947     cp "conftest.in" "conftest.nl"
12948     $as_echo 'GREP' >> "conftest.nl"
12949     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
12950     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12951     as_fn_arith $ac_count + 1 && ac_count=$as_val
12952     if test $ac_count -gt ${ac_path_GREP_max-0}; then
12953       # Best one so far, save it but keep looking for a better one
12954       ac_cv_path_GREP="$ac_path_GREP"
12955       ac_path_GREP_max=$ac_count
12956     fi
12957     # 10*(2^10) chars as input seems more than enough
12958     test $ac_count -gt 10 && break
12959   done
12960   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12961 esac
12962 
12963       $ac_path_GREP_found && break 3
12964     done
12965   done
12966   done
12967 IFS=$as_save_IFS
12968   if test -z "$ac_cv_path_GREP"; then
12969     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12970   fi
12971 else
12972   ac_cv_path_GREP=$GREP
12973 fi
12974 
12975 fi
12976 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
12977 $as_echo "$ac_cv_path_GREP" >&6; }
12978  GREP="$ac_cv_path_GREP"
12979 
12980 
12981     else
12982       # If it succeeded, then it was overridden by the user. We will use it
12983       # for the tool.
12984 
12985       # First remove it from the list of overridden variables, so we can test
12986       # for unknown variables in the end.
12987       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12988 
12989       # Check if we try to supply an empty value
12990       if test "x$GREP" = x; then
12991         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
12992 $as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
12993         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
12994 $as_echo_n "checking for GREP... " >&6; }
12995         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12996 $as_echo "disabled" >&6; }
12997       else
12998         # Check if the provided tool contains a complete path.
12999         tool_specified="$GREP"
13000         tool_basename="${tool_specified##*/}"
13001         if test "x$tool_basename" = "x$tool_specified"; then
13002           # A command without a complete path is provided, search $PATH.
13003           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
13004 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
13005           # Extract the first word of "$tool_basename", so it can be a program name with args.
13006 set dummy $tool_basename; ac_word=$2
13007 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13008 $as_echo_n "checking for $ac_word... " >&6; }
13009 if ${ac_cv_path_GREP+:} false; then :
13010   $as_echo_n "(cached) " >&6
13011 else
13012   case $GREP in
13013   [\\/]* | ?:[\\/]*)
13014   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
13015   ;;
13016   *)
13017   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13018 for as_dir in $PATH
13019 do
13020   IFS=$as_save_IFS
13021   test -z "$as_dir" && as_dir=.
13022     for ac_exec_ext in '' $ac_executable_extensions; do
13023   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13024     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
13025     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13026     break 2
13027   fi
13028 done
13029   done
13030 IFS=$as_save_IFS
13031 
13032   ;;
13033 esac
13034 fi
13035 GREP=$ac_cv_path_GREP
13036 if test -n "$GREP"; then
13037   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
13038 $as_echo "$GREP" >&6; }
13039 else
13040   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13041 $as_echo "no" >&6; }
13042 fi
13043 
13044 
13045           if test "x$GREP" = x; then
13046             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13047           fi
13048         else
13049           # Otherwise we believe it is a complete path. Use it as it is.
13050           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
13051 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
13052           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
13053 $as_echo_n "checking for GREP... " >&6; }
13054           if test ! -x "$tool_specified"; then
13055             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13056 $as_echo "not found" >&6; }
13057             as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13058           fi
13059           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13060 $as_echo "$tool_specified" >&6; }
13061         fi
13062       fi
13063     fi
13064 
13065   fi
13066 
13067 
13068   if test "x$GREP" = x; then
13069     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
13070   fi
13071 
13072 
13073 
13074 
13075   # Publish this variable in the help.
13076 
13077 
13078   if [ -z "${EGREP+x}" ]; then
13079     # The variable is not set by user, try to locate tool using the code snippet
13080     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13081 $as_echo_n "checking for egrep... " >&6; }
13082 if ${ac_cv_path_EGREP+:} false; then :
13083   $as_echo_n "(cached) " >&6
13084 else
13085   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13086    then ac_cv_path_EGREP="$GREP -E"
13087    else
13088      if test -z "$EGREP"; then
13089   ac_path_EGREP_found=false
13090   # Loop through the user's path and test for each of PROGNAME-LIST
13091   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13092 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13093 do
13094   IFS=$as_save_IFS
13095   test -z "$as_dir" && as_dir=.
13096     for ac_prog in egrep; do
13097     for ac_exec_ext in '' $ac_executable_extensions; do
13098       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13099       as_fn_executable_p "$ac_path_EGREP" || continue
13100 # Check for GNU ac_path_EGREP and select it if it is found.
13101   # Check for GNU $ac_path_EGREP
13102 case `"$ac_path_EGREP" --version 2>&1` in
13103 *GNU*)
13104   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13105 *)
13106   ac_count=0
13107   $as_echo_n 0123456789 >"conftest.in"
13108   while :
13109   do
13110     cat "conftest.in" "conftest.in" >"conftest.tmp"
13111     mv "conftest.tmp" "conftest.in"
13112     cp "conftest.in" "conftest.nl"
13113     $as_echo 'EGREP' >> "conftest.nl"
13114     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13115     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13116     as_fn_arith $ac_count + 1 && ac_count=$as_val
13117     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13118       # Best one so far, save it but keep looking for a better one
13119       ac_cv_path_EGREP="$ac_path_EGREP"
13120       ac_path_EGREP_max=$ac_count
13121     fi
13122     # 10*(2^10) chars as input seems more than enough
13123     test $ac_count -gt 10 && break
13124   done
13125   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13126 esac
13127 
13128       $ac_path_EGREP_found && break 3
13129     done
13130   done
13131   done
13132 IFS=$as_save_IFS
13133   if test -z "$ac_cv_path_EGREP"; then
13134     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13135   fi
13136 else
13137   ac_cv_path_EGREP=$EGREP
13138 fi
13139 
13140    fi
13141 fi
13142 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13143 $as_echo "$ac_cv_path_EGREP" >&6; }
13144  EGREP="$ac_cv_path_EGREP"
13145 
13146 
13147   else
13148     # The variable is set, but is it from the command line or the environment?
13149 
13150     # Try to remove the string !EGREP! from our list.
13151     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
13152     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13153       # If it failed, the variable was not from the command line. Ignore it,
13154       # but warn the user (except for BASH, which is always set by the calling BASH).
13155       if test "xEGREP" != xBASH; then
13156         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
13157 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
13158       fi
13159       # Try to locate tool using the code snippet
13160       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
13161 $as_echo_n "checking for egrep... " >&6; }
13162 if ${ac_cv_path_EGREP+:} false; then :
13163   $as_echo_n "(cached) " >&6
13164 else
13165   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
13166    then ac_cv_path_EGREP="$GREP -E"
13167    else
13168      if test -z "$EGREP"; then
13169   ac_path_EGREP_found=false
13170   # Loop through the user's path and test for each of PROGNAME-LIST
13171   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13172 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13173 do
13174   IFS=$as_save_IFS
13175   test -z "$as_dir" && as_dir=.
13176     for ac_prog in egrep; do
13177     for ac_exec_ext in '' $ac_executable_extensions; do
13178       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
13179       as_fn_executable_p "$ac_path_EGREP" || continue
13180 # Check for GNU ac_path_EGREP and select it if it is found.
13181   # Check for GNU $ac_path_EGREP
13182 case `"$ac_path_EGREP" --version 2>&1` in
13183 *GNU*)
13184   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
13185 *)
13186   ac_count=0
13187   $as_echo_n 0123456789 >"conftest.in"
13188   while :
13189   do
13190     cat "conftest.in" "conftest.in" >"conftest.tmp"
13191     mv "conftest.tmp" "conftest.in"
13192     cp "conftest.in" "conftest.nl"
13193     $as_echo 'EGREP' >> "conftest.nl"
13194     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
13195     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13196     as_fn_arith $ac_count + 1 && ac_count=$as_val
13197     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
13198       # Best one so far, save it but keep looking for a better one
13199       ac_cv_path_EGREP="$ac_path_EGREP"
13200       ac_path_EGREP_max=$ac_count
13201     fi
13202     # 10*(2^10) chars as input seems more than enough
13203     test $ac_count -gt 10 && break
13204   done
13205   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13206 esac
13207 
13208       $ac_path_EGREP_found && break 3
13209     done
13210   done
13211   done
13212 IFS=$as_save_IFS
13213   if test -z "$ac_cv_path_EGREP"; then
13214     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13215   fi
13216 else
13217   ac_cv_path_EGREP=$EGREP
13218 fi
13219 
13220    fi
13221 fi
13222 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
13223 $as_echo "$ac_cv_path_EGREP" >&6; }
13224  EGREP="$ac_cv_path_EGREP"
13225 
13226 
13227     else
13228       # If it succeeded, then it was overridden by the user. We will use it
13229       # for the tool.
13230 
13231       # First remove it from the list of overridden variables, so we can test
13232       # for unknown variables in the end.
13233       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13234 
13235       # Check if we try to supply an empty value
13236       if test "x$EGREP" = x; then
13237         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
13238 $as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
13239         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13240 $as_echo_n "checking for EGREP... " >&6; }
13241         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13242 $as_echo "disabled" >&6; }
13243       else
13244         # Check if the provided tool contains a complete path.
13245         tool_specified="$EGREP"
13246         tool_basename="${tool_specified##*/}"
13247         if test "x$tool_basename" = "x$tool_specified"; then
13248           # A command without a complete path is provided, search $PATH.
13249           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
13250 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
13251           # Extract the first word of "$tool_basename", so it can be a program name with args.
13252 set dummy $tool_basename; ac_word=$2
13253 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13254 $as_echo_n "checking for $ac_word... " >&6; }
13255 if ${ac_cv_path_EGREP+:} false; then :
13256   $as_echo_n "(cached) " >&6
13257 else
13258   case $EGREP in
13259   [\\/]* | ?:[\\/]*)
13260   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
13261   ;;
13262   *)
13263   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13264 for as_dir in $PATH
13265 do
13266   IFS=$as_save_IFS
13267   test -z "$as_dir" && as_dir=.
13268     for ac_exec_ext in '' $ac_executable_extensions; do
13269   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13270     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
13271     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13272     break 2
13273   fi
13274 done
13275   done
13276 IFS=$as_save_IFS
13277 
13278   ;;
13279 esac
13280 fi
13281 EGREP=$ac_cv_path_EGREP
13282 if test -n "$EGREP"; then
13283   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
13284 $as_echo "$EGREP" >&6; }
13285 else
13286   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13287 $as_echo "no" >&6; }
13288 fi
13289 
13290 
13291           if test "x$EGREP" = x; then
13292             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13293           fi
13294         else
13295           # Otherwise we believe it is a complete path. Use it as it is.
13296           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
13297 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
13298           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
13299 $as_echo_n "checking for EGREP... " >&6; }
13300           if test ! -x "$tool_specified"; then
13301             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13302 $as_echo "not found" >&6; }
13303             as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13304           fi
13305           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13306 $as_echo "$tool_specified" >&6; }
13307         fi
13308       fi
13309     fi
13310 
13311   fi
13312 
13313 
13314   if test "x$EGREP" = x; then
13315     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
13316   fi
13317 
13318 
13319 
13320 
13321   # Publish this variable in the help.
13322 
13323 
13324   if [ -z "${FGREP+x}" ]; then
13325     # The variable is not set by user, try to locate tool using the code snippet
13326     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13327 $as_echo_n "checking for fgrep... " >&6; }
13328 if ${ac_cv_path_FGREP+:} false; then :
13329   $as_echo_n "(cached) " >&6
13330 else
13331   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13332    then ac_cv_path_FGREP="$GREP -F"
13333    else
13334      if test -z "$FGREP"; then
13335   ac_path_FGREP_found=false
13336   # Loop through the user's path and test for each of PROGNAME-LIST
13337   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13338 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13339 do
13340   IFS=$as_save_IFS
13341   test -z "$as_dir" && as_dir=.
13342     for ac_prog in fgrep; do
13343     for ac_exec_ext in '' $ac_executable_extensions; do
13344       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13345       as_fn_executable_p "$ac_path_FGREP" || continue
13346 # Check for GNU ac_path_FGREP and select it if it is found.
13347   # Check for GNU $ac_path_FGREP
13348 case `"$ac_path_FGREP" --version 2>&1` in
13349 *GNU*)
13350   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13351 *)
13352   ac_count=0
13353   $as_echo_n 0123456789 >"conftest.in"
13354   while :
13355   do
13356     cat "conftest.in" "conftest.in" >"conftest.tmp"
13357     mv "conftest.tmp" "conftest.in"
13358     cp "conftest.in" "conftest.nl"
13359     $as_echo 'FGREP' >> "conftest.nl"
13360     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13361     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13362     as_fn_arith $ac_count + 1 && ac_count=$as_val
13363     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13364       # Best one so far, save it but keep looking for a better one
13365       ac_cv_path_FGREP="$ac_path_FGREP"
13366       ac_path_FGREP_max=$ac_count
13367     fi
13368     # 10*(2^10) chars as input seems more than enough
13369     test $ac_count -gt 10 && break
13370   done
13371   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13372 esac
13373 
13374       $ac_path_FGREP_found && break 3
13375     done
13376   done
13377   done
13378 IFS=$as_save_IFS
13379   if test -z "$ac_cv_path_FGREP"; then
13380     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13381   fi
13382 else
13383   ac_cv_path_FGREP=$FGREP
13384 fi
13385 
13386    fi
13387 fi
13388 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13389 $as_echo "$ac_cv_path_FGREP" >&6; }
13390  FGREP="$ac_cv_path_FGREP"
13391 
13392 
13393   else
13394     # The variable is set, but is it from the command line or the environment?
13395 
13396     # Try to remove the string !FGREP! from our list.
13397     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
13398     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13399       # If it failed, the variable was not from the command line. Ignore it,
13400       # but warn the user (except for BASH, which is always set by the calling BASH).
13401       if test "xFGREP" != xBASH; then
13402         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
13403 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
13404       fi
13405       # Try to locate tool using the code snippet
13406       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
13407 $as_echo_n "checking for fgrep... " >&6; }
13408 if ${ac_cv_path_FGREP+:} false; then :
13409   $as_echo_n "(cached) " >&6
13410 else
13411   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
13412    then ac_cv_path_FGREP="$GREP -F"
13413    else
13414      if test -z "$FGREP"; then
13415   ac_path_FGREP_found=false
13416   # Loop through the user's path and test for each of PROGNAME-LIST
13417   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13418 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
13419 do
13420   IFS=$as_save_IFS
13421   test -z "$as_dir" && as_dir=.
13422     for ac_prog in fgrep; do
13423     for ac_exec_ext in '' $ac_executable_extensions; do
13424       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
13425       as_fn_executable_p "$ac_path_FGREP" || continue
13426 # Check for GNU ac_path_FGREP and select it if it is found.
13427   # Check for GNU $ac_path_FGREP
13428 case `"$ac_path_FGREP" --version 2>&1` in
13429 *GNU*)
13430   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
13431 *)
13432   ac_count=0
13433   $as_echo_n 0123456789 >"conftest.in"
13434   while :
13435   do
13436     cat "conftest.in" "conftest.in" >"conftest.tmp"
13437     mv "conftest.tmp" "conftest.in"
13438     cp "conftest.in" "conftest.nl"
13439     $as_echo 'FGREP' >> "conftest.nl"
13440     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
13441     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13442     as_fn_arith $ac_count + 1 && ac_count=$as_val
13443     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
13444       # Best one so far, save it but keep looking for a better one
13445       ac_cv_path_FGREP="$ac_path_FGREP"
13446       ac_path_FGREP_max=$ac_count
13447     fi
13448     # 10*(2^10) chars as input seems more than enough
13449     test $ac_count -gt 10 && break
13450   done
13451   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13452 esac
13453 
13454       $ac_path_FGREP_found && break 3
13455     done
13456   done
13457   done
13458 IFS=$as_save_IFS
13459   if test -z "$ac_cv_path_FGREP"; then
13460     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
13461   fi
13462 else
13463   ac_cv_path_FGREP=$FGREP
13464 fi
13465 
13466    fi
13467 fi
13468 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
13469 $as_echo "$ac_cv_path_FGREP" >&6; }
13470  FGREP="$ac_cv_path_FGREP"
13471 
13472 
13473     else
13474       # If it succeeded, then it was overridden by the user. We will use it
13475       # for the tool.
13476 
13477       # First remove it from the list of overridden variables, so we can test
13478       # for unknown variables in the end.
13479       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13480 
13481       # Check if we try to supply an empty value
13482       if test "x$FGREP" = x; then
13483         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
13484 $as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
13485         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13486 $as_echo_n "checking for FGREP... " >&6; }
13487         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13488 $as_echo "disabled" >&6; }
13489       else
13490         # Check if the provided tool contains a complete path.
13491         tool_specified="$FGREP"
13492         tool_basename="${tool_specified##*/}"
13493         if test "x$tool_basename" = "x$tool_specified"; then
13494           # A command without a complete path is provided, search $PATH.
13495           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
13496 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
13497           # Extract the first word of "$tool_basename", so it can be a program name with args.
13498 set dummy $tool_basename; ac_word=$2
13499 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13500 $as_echo_n "checking for $ac_word... " >&6; }
13501 if ${ac_cv_path_FGREP+:} false; then :
13502   $as_echo_n "(cached) " >&6
13503 else
13504   case $FGREP in
13505   [\\/]* | ?:[\\/]*)
13506   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
13507   ;;
13508   *)
13509   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13510 for as_dir in $PATH
13511 do
13512   IFS=$as_save_IFS
13513   test -z "$as_dir" && as_dir=.
13514     for ac_exec_ext in '' $ac_executable_extensions; do
13515   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13516     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
13517     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13518     break 2
13519   fi
13520 done
13521   done
13522 IFS=$as_save_IFS
13523 
13524   ;;
13525 esac
13526 fi
13527 FGREP=$ac_cv_path_FGREP
13528 if test -n "$FGREP"; then
13529   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
13530 $as_echo "$FGREP" >&6; }
13531 else
13532   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13533 $as_echo "no" >&6; }
13534 fi
13535 
13536 
13537           if test "x$FGREP" = x; then
13538             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13539           fi
13540         else
13541           # Otherwise we believe it is a complete path. Use it as it is.
13542           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
13543 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
13544           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
13545 $as_echo_n "checking for FGREP... " >&6; }
13546           if test ! -x "$tool_specified"; then
13547             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13548 $as_echo "not found" >&6; }
13549             as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
13550           fi
13551           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13552 $as_echo "$tool_specified" >&6; }
13553         fi
13554       fi
13555     fi
13556 
13557   fi
13558 
13559 
13560   if test "x$FGREP" = x; then
13561     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
13562   fi
13563 
13564 
13565 
13566 
13567   # Publish this variable in the help.
13568 
13569 
13570   if [ -z "${SED+x}" ]; then
13571     # The variable is not set by user, try to locate tool using the code snippet
13572     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13573 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13574 if ${ac_cv_path_SED+:} false; then :
13575   $as_echo_n "(cached) " >&6
13576 else
13577             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13578      for ac_i in 1 2 3 4 5 6 7; do
13579        ac_script="$ac_script$as_nl$ac_script"
13580      done
13581      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13582      { ac_script=; unset ac_script;}
13583      if test -z "$SED"; then
13584   ac_path_SED_found=false
13585   # Loop through the user's path and test for each of PROGNAME-LIST
13586   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13587 for as_dir in $PATH
13588 do
13589   IFS=$as_save_IFS
13590   test -z "$as_dir" && as_dir=.
13591     for ac_prog in sed gsed; do
13592     for ac_exec_ext in '' $ac_executable_extensions; do
13593       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13594       as_fn_executable_p "$ac_path_SED" || continue
13595 # Check for GNU ac_path_SED and select it if it is found.
13596   # Check for GNU $ac_path_SED
13597 case `"$ac_path_SED" --version 2>&1` in
13598 *GNU*)
13599   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13600 *)
13601   ac_count=0
13602   $as_echo_n 0123456789 >"conftest.in"
13603   while :
13604   do
13605     cat "conftest.in" "conftest.in" >"conftest.tmp"
13606     mv "conftest.tmp" "conftest.in"
13607     cp "conftest.in" "conftest.nl"
13608     $as_echo '' >> "conftest.nl"
13609     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13610     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13611     as_fn_arith $ac_count + 1 && ac_count=$as_val
13612     if test $ac_count -gt ${ac_path_SED_max-0}; then
13613       # Best one so far, save it but keep looking for a better one
13614       ac_cv_path_SED="$ac_path_SED"
13615       ac_path_SED_max=$ac_count
13616     fi
13617     # 10*(2^10) chars as input seems more than enough
13618     test $ac_count -gt 10 && break
13619   done
13620   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13621 esac
13622 
13623       $ac_path_SED_found && break 3
13624     done
13625   done
13626   done
13627 IFS=$as_save_IFS
13628   if test -z "$ac_cv_path_SED"; then
13629     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13630   fi
13631 else
13632   ac_cv_path_SED=$SED
13633 fi
13634 
13635 fi
13636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13637 $as_echo "$ac_cv_path_SED" >&6; }
13638  SED="$ac_cv_path_SED"
13639   rm -f conftest.sed
13640 
13641   else
13642     # The variable is set, but is it from the command line or the environment?
13643 
13644     # Try to remove the string !SED! from our list.
13645     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
13646     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13647       # If it failed, the variable was not from the command line. Ignore it,
13648       # but warn the user (except for BASH, which is always set by the calling BASH).
13649       if test "xSED" != xBASH; then
13650         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
13651 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
13652       fi
13653       # Try to locate tool using the code snippet
13654       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
13655 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
13656 if ${ac_cv_path_SED+:} false; then :
13657   $as_echo_n "(cached) " >&6
13658 else
13659             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
13660      for ac_i in 1 2 3 4 5 6 7; do
13661        ac_script="$ac_script$as_nl$ac_script"
13662      done
13663      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
13664      { ac_script=; unset ac_script;}
13665      if test -z "$SED"; then
13666   ac_path_SED_found=false
13667   # Loop through the user's path and test for each of PROGNAME-LIST
13668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13669 for as_dir in $PATH
13670 do
13671   IFS=$as_save_IFS
13672   test -z "$as_dir" && as_dir=.
13673     for ac_prog in sed gsed; do
13674     for ac_exec_ext in '' $ac_executable_extensions; do
13675       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
13676       as_fn_executable_p "$ac_path_SED" || continue
13677 # Check for GNU ac_path_SED and select it if it is found.
13678   # Check for GNU $ac_path_SED
13679 case `"$ac_path_SED" --version 2>&1` in
13680 *GNU*)
13681   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
13682 *)
13683   ac_count=0
13684   $as_echo_n 0123456789 >"conftest.in"
13685   while :
13686   do
13687     cat "conftest.in" "conftest.in" >"conftest.tmp"
13688     mv "conftest.tmp" "conftest.in"
13689     cp "conftest.in" "conftest.nl"
13690     $as_echo '' >> "conftest.nl"
13691     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
13692     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
13693     as_fn_arith $ac_count + 1 && ac_count=$as_val
13694     if test $ac_count -gt ${ac_path_SED_max-0}; then
13695       # Best one so far, save it but keep looking for a better one
13696       ac_cv_path_SED="$ac_path_SED"
13697       ac_path_SED_max=$ac_count
13698     fi
13699     # 10*(2^10) chars as input seems more than enough
13700     test $ac_count -gt 10 && break
13701   done
13702   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
13703 esac
13704 
13705       $ac_path_SED_found && break 3
13706     done
13707   done
13708   done
13709 IFS=$as_save_IFS
13710   if test -z "$ac_cv_path_SED"; then
13711     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
13712   fi
13713 else
13714   ac_cv_path_SED=$SED
13715 fi
13716 
13717 fi
13718 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
13719 $as_echo "$ac_cv_path_SED" >&6; }
13720  SED="$ac_cv_path_SED"
13721   rm -f conftest.sed
13722 
13723     else
13724       # If it succeeded, then it was overridden by the user. We will use it
13725       # for the tool.
13726 
13727       # First remove it from the list of overridden variables, so we can test
13728       # for unknown variables in the end.
13729       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13730 
13731       # Check if we try to supply an empty value
13732       if test "x$SED" = x; then
13733         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
13734 $as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
13735         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13736 $as_echo_n "checking for SED... " >&6; }
13737         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13738 $as_echo "disabled" >&6; }
13739       else
13740         # Check if the provided tool contains a complete path.
13741         tool_specified="$SED"
13742         tool_basename="${tool_specified##*/}"
13743         if test "x$tool_basename" = "x$tool_specified"; then
13744           # A command without a complete path is provided, search $PATH.
13745           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
13746 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
13747           # Extract the first word of "$tool_basename", so it can be a program name with args.
13748 set dummy $tool_basename; ac_word=$2
13749 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13750 $as_echo_n "checking for $ac_word... " >&6; }
13751 if ${ac_cv_path_SED+:} false; then :
13752   $as_echo_n "(cached) " >&6
13753 else
13754   case $SED in
13755   [\\/]* | ?:[\\/]*)
13756   ac_cv_path_SED="$SED" # Let the user override the test with a path.
13757   ;;
13758   *)
13759   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13760 for as_dir in $PATH
13761 do
13762   IFS=$as_save_IFS
13763   test -z "$as_dir" && as_dir=.
13764     for ac_exec_ext in '' $ac_executable_extensions; do
13765   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13766     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
13767     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13768     break 2
13769   fi
13770 done
13771   done
13772 IFS=$as_save_IFS
13773 
13774   ;;
13775 esac
13776 fi
13777 SED=$ac_cv_path_SED
13778 if test -n "$SED"; then
13779   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
13780 $as_echo "$SED" >&6; }
13781 else
13782   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13783 $as_echo "no" >&6; }
13784 fi
13785 
13786 
13787           if test "x$SED" = x; then
13788             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13789           fi
13790         else
13791           # Otherwise we believe it is a complete path. Use it as it is.
13792           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
13793 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
13794           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
13795 $as_echo_n "checking for SED... " >&6; }
13796           if test ! -x "$tool_specified"; then
13797             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13798 $as_echo "not found" >&6; }
13799             as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
13800           fi
13801           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13802 $as_echo "$tool_specified" >&6; }
13803         fi
13804       fi
13805     fi
13806 
13807   fi
13808 
13809 
13810   if test "x$SED" = x; then
13811     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
13812   fi
13813 
13814 
13815 
13816   # Always force rm.
13817   RM="$RM -f"
13818 
13819   # pwd behaves differently on various platforms and some don't support the -L flag.
13820   # Always use the bash builtin pwd to get uniform behavior.
13821   THEPWDCMD=pwd
13822 
13823   # These are not required on all platforms
13824 
13825 
13826   # Publish this variable in the help.
13827 
13828 
13829   if [ -z "${CYGPATH+x}" ]; then
13830     # The variable is not set by user, try to locate tool using the code snippet
13831     for ac_prog in cygpath
13832 do
13833   # Extract the first word of "$ac_prog", so it can be a program name with args.
13834 set dummy $ac_prog; ac_word=$2
13835 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13836 $as_echo_n "checking for $ac_word... " >&6; }
13837 if ${ac_cv_path_CYGPATH+:} false; then :
13838   $as_echo_n "(cached) " >&6
13839 else
13840   case $CYGPATH in
13841   [\\/]* | ?:[\\/]*)
13842   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13843   ;;
13844   *)
13845   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13846 for as_dir in $PATH
13847 do
13848   IFS=$as_save_IFS
13849   test -z "$as_dir" && as_dir=.
13850     for ac_exec_ext in '' $ac_executable_extensions; do
13851   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13852     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13853     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13854     break 2
13855   fi
13856 done
13857   done
13858 IFS=$as_save_IFS
13859 
13860   ;;
13861 esac
13862 fi
13863 CYGPATH=$ac_cv_path_CYGPATH
13864 if test -n "$CYGPATH"; then
13865   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13866 $as_echo "$CYGPATH" >&6; }
13867 else
13868   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13869 $as_echo "no" >&6; }
13870 fi
13871 
13872 
13873   test -n "$CYGPATH" && break
13874 done
13875 
13876   else
13877     # The variable is set, but is it from the command line or the environment?
13878 
13879     # Try to remove the string !CYGPATH! from our list.
13880     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
13881     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13882       # If it failed, the variable was not from the command line. Ignore it,
13883       # but warn the user (except for BASH, which is always set by the calling BASH).
13884       if test "xCYGPATH" != xBASH; then
13885         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
13886 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
13887       fi
13888       # Try to locate tool using the code snippet
13889       for ac_prog in cygpath
13890 do
13891   # Extract the first word of "$ac_prog", so it can be a program name with args.
13892 set dummy $ac_prog; ac_word=$2
13893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13894 $as_echo_n "checking for $ac_word... " >&6; }
13895 if ${ac_cv_path_CYGPATH+:} false; then :
13896   $as_echo_n "(cached) " >&6
13897 else
13898   case $CYGPATH in
13899   [\\/]* | ?:[\\/]*)
13900   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13901   ;;
13902   *)
13903   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13904 for as_dir in $PATH
13905 do
13906   IFS=$as_save_IFS
13907   test -z "$as_dir" && as_dir=.
13908     for ac_exec_ext in '' $ac_executable_extensions; do
13909   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13910     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13911     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13912     break 2
13913   fi
13914 done
13915   done
13916 IFS=$as_save_IFS
13917 
13918   ;;
13919 esac
13920 fi
13921 CYGPATH=$ac_cv_path_CYGPATH
13922 if test -n "$CYGPATH"; then
13923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13924 $as_echo "$CYGPATH" >&6; }
13925 else
13926   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13927 $as_echo "no" >&6; }
13928 fi
13929 
13930 
13931   test -n "$CYGPATH" && break
13932 done
13933 
13934     else
13935       # If it succeeded, then it was overridden by the user. We will use it
13936       # for the tool.
13937 
13938       # First remove it from the list of overridden variables, so we can test
13939       # for unknown variables in the end.
13940       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13941 
13942       # Check if we try to supply an empty value
13943       if test "x$CYGPATH" = x; then
13944         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
13945 $as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
13946         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
13947 $as_echo_n "checking for CYGPATH... " >&6; }
13948         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
13949 $as_echo "disabled" >&6; }
13950       else
13951         # Check if the provided tool contains a complete path.
13952         tool_specified="$CYGPATH"
13953         tool_basename="${tool_specified##*/}"
13954         if test "x$tool_basename" = "x$tool_specified"; then
13955           # A command without a complete path is provided, search $PATH.
13956           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
13957 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
13958           # Extract the first word of "$tool_basename", so it can be a program name with args.
13959 set dummy $tool_basename; ac_word=$2
13960 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13961 $as_echo_n "checking for $ac_word... " >&6; }
13962 if ${ac_cv_path_CYGPATH+:} false; then :
13963   $as_echo_n "(cached) " >&6
13964 else
13965   case $CYGPATH in
13966   [\\/]* | ?:[\\/]*)
13967   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
13968   ;;
13969   *)
13970   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13971 for as_dir in $PATH
13972 do
13973   IFS=$as_save_IFS
13974   test -z "$as_dir" && as_dir=.
13975     for ac_exec_ext in '' $ac_executable_extensions; do
13976   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13977     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
13978     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13979     break 2
13980   fi
13981 done
13982   done
13983 IFS=$as_save_IFS
13984 
13985   ;;
13986 esac
13987 fi
13988 CYGPATH=$ac_cv_path_CYGPATH
13989 if test -n "$CYGPATH"; then
13990   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
13991 $as_echo "$CYGPATH" >&6; }
13992 else
13993   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13994 $as_echo "no" >&6; }
13995 fi
13996 
13997 
13998           if test "x$CYGPATH" = x; then
13999             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14000           fi
14001         else
14002           # Otherwise we believe it is a complete path. Use it as it is.
14003           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
14004 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
14005           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
14006 $as_echo_n "checking for CYGPATH... " >&6; }
14007           if test ! -x "$tool_specified"; then
14008             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14009 $as_echo "not found" >&6; }
14010             as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
14011           fi
14012           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14013 $as_echo "$tool_specified" >&6; }
14014         fi
14015       fi
14016     fi
14017 
14018   fi
14019 
14020 
14021 
14022 
14023   # Publish this variable in the help.
14024 
14025 
14026   if [ -z "${READLINK+x}" ]; then
14027     # The variable is not set by user, try to locate tool using the code snippet
14028     for ac_prog in greadlink readlink
14029 do
14030   # Extract the first word of "$ac_prog", so it can be a program name with args.
14031 set dummy $ac_prog; ac_word=$2
14032 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14033 $as_echo_n "checking for $ac_word... " >&6; }
14034 if ${ac_cv_path_READLINK+:} false; then :
14035   $as_echo_n "(cached) " >&6
14036 else
14037   case $READLINK in
14038   [\\/]* | ?:[\\/]*)
14039   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14040   ;;
14041   *)
14042   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14043 for as_dir in $PATH
14044 do
14045   IFS=$as_save_IFS
14046   test -z "$as_dir" && as_dir=.
14047     for ac_exec_ext in '' $ac_executable_extensions; do
14048   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14049     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14050     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14051     break 2
14052   fi
14053 done
14054   done
14055 IFS=$as_save_IFS
14056 
14057   ;;
14058 esac
14059 fi
14060 READLINK=$ac_cv_path_READLINK
14061 if test -n "$READLINK"; then
14062   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14063 $as_echo "$READLINK" >&6; }
14064 else
14065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14066 $as_echo "no" >&6; }
14067 fi
14068 
14069 
14070   test -n "$READLINK" && break
14071 done
14072 
14073   else
14074     # The variable is set, but is it from the command line or the environment?
14075 
14076     # Try to remove the string !READLINK! from our list.
14077     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
14078     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14079       # If it failed, the variable was not from the command line. Ignore it,
14080       # but warn the user (except for BASH, which is always set by the calling BASH).
14081       if test "xREADLINK" != xBASH; then
14082         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
14083 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
14084       fi
14085       # Try to locate tool using the code snippet
14086       for ac_prog in greadlink readlink
14087 do
14088   # Extract the first word of "$ac_prog", so it can be a program name with args.
14089 set dummy $ac_prog; ac_word=$2
14090 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14091 $as_echo_n "checking for $ac_word... " >&6; }
14092 if ${ac_cv_path_READLINK+:} false; then :
14093   $as_echo_n "(cached) " >&6
14094 else
14095   case $READLINK in
14096   [\\/]* | ?:[\\/]*)
14097   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14098   ;;
14099   *)
14100   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14101 for as_dir in $PATH
14102 do
14103   IFS=$as_save_IFS
14104   test -z "$as_dir" && as_dir=.
14105     for ac_exec_ext in '' $ac_executable_extensions; do
14106   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14107     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14108     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14109     break 2
14110   fi
14111 done
14112   done
14113 IFS=$as_save_IFS
14114 
14115   ;;
14116 esac
14117 fi
14118 READLINK=$ac_cv_path_READLINK
14119 if test -n "$READLINK"; then
14120   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14121 $as_echo "$READLINK" >&6; }
14122 else
14123   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14124 $as_echo "no" >&6; }
14125 fi
14126 
14127 
14128   test -n "$READLINK" && break
14129 done
14130 
14131     else
14132       # If it succeeded, then it was overridden by the user. We will use it
14133       # for the tool.
14134 
14135       # First remove it from the list of overridden variables, so we can test
14136       # for unknown variables in the end.
14137       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14138 
14139       # Check if we try to supply an empty value
14140       if test "x$READLINK" = x; then
14141         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
14142 $as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
14143         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14144 $as_echo_n "checking for READLINK... " >&6; }
14145         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14146 $as_echo "disabled" >&6; }
14147       else
14148         # Check if the provided tool contains a complete path.
14149         tool_specified="$READLINK"
14150         tool_basename="${tool_specified##*/}"
14151         if test "x$tool_basename" = "x$tool_specified"; then
14152           # A command without a complete path is provided, search $PATH.
14153           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
14154 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
14155           # Extract the first word of "$tool_basename", so it can be a program name with args.
14156 set dummy $tool_basename; ac_word=$2
14157 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14158 $as_echo_n "checking for $ac_word... " >&6; }
14159 if ${ac_cv_path_READLINK+:} false; then :
14160   $as_echo_n "(cached) " >&6
14161 else
14162   case $READLINK in
14163   [\\/]* | ?:[\\/]*)
14164   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
14165   ;;
14166   *)
14167   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14168 for as_dir in $PATH
14169 do
14170   IFS=$as_save_IFS
14171   test -z "$as_dir" && as_dir=.
14172     for ac_exec_ext in '' $ac_executable_extensions; do
14173   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14174     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
14175     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14176     break 2
14177   fi
14178 done
14179   done
14180 IFS=$as_save_IFS
14181 
14182   ;;
14183 esac
14184 fi
14185 READLINK=$ac_cv_path_READLINK
14186 if test -n "$READLINK"; then
14187   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
14188 $as_echo "$READLINK" >&6; }
14189 else
14190   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14191 $as_echo "no" >&6; }
14192 fi
14193 
14194 
14195           if test "x$READLINK" = x; then
14196             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14197           fi
14198         else
14199           # Otherwise we believe it is a complete path. Use it as it is.
14200           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
14201 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
14202           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
14203 $as_echo_n "checking for READLINK... " >&6; }
14204           if test ! -x "$tool_specified"; then
14205             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14206 $as_echo "not found" >&6; }
14207             as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
14208           fi
14209           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14210 $as_echo "$tool_specified" >&6; }
14211         fi
14212       fi
14213     fi
14214 
14215   fi
14216 
14217 
14218 
14219 
14220   # Publish this variable in the help.
14221 
14222 
14223   if [ -z "${DF+x}" ]; then
14224     # The variable is not set by user, try to locate tool using the code snippet
14225     for ac_prog in df
14226 do
14227   # Extract the first word of "$ac_prog", so it can be a program name with args.
14228 set dummy $ac_prog; ac_word=$2
14229 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14230 $as_echo_n "checking for $ac_word... " >&6; }
14231 if ${ac_cv_path_DF+:} false; then :
14232   $as_echo_n "(cached) " >&6
14233 else
14234   case $DF in
14235   [\\/]* | ?:[\\/]*)
14236   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14237   ;;
14238   *)
14239   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14240 for as_dir in $PATH
14241 do
14242   IFS=$as_save_IFS
14243   test -z "$as_dir" && as_dir=.
14244     for ac_exec_ext in '' $ac_executable_extensions; do
14245   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14246     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14247     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14248     break 2
14249   fi
14250 done
14251   done
14252 IFS=$as_save_IFS
14253 
14254   ;;
14255 esac
14256 fi
14257 DF=$ac_cv_path_DF
14258 if test -n "$DF"; then
14259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14260 $as_echo "$DF" >&6; }
14261 else
14262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14263 $as_echo "no" >&6; }
14264 fi
14265 
14266 
14267   test -n "$DF" && break
14268 done
14269 
14270   else
14271     # The variable is set, but is it from the command line or the environment?
14272 
14273     # Try to remove the string !DF! from our list.
14274     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
14275     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14276       # If it failed, the variable was not from the command line. Ignore it,
14277       # but warn the user (except for BASH, which is always set by the calling BASH).
14278       if test "xDF" != xBASH; then
14279         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
14280 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
14281       fi
14282       # Try to locate tool using the code snippet
14283       for ac_prog in df
14284 do
14285   # Extract the first word of "$ac_prog", so it can be a program name with args.
14286 set dummy $ac_prog; ac_word=$2
14287 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14288 $as_echo_n "checking for $ac_word... " >&6; }
14289 if ${ac_cv_path_DF+:} false; then :
14290   $as_echo_n "(cached) " >&6
14291 else
14292   case $DF in
14293   [\\/]* | ?:[\\/]*)
14294   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14295   ;;
14296   *)
14297   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14298 for as_dir in $PATH
14299 do
14300   IFS=$as_save_IFS
14301   test -z "$as_dir" && as_dir=.
14302     for ac_exec_ext in '' $ac_executable_extensions; do
14303   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14304     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14305     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14306     break 2
14307   fi
14308 done
14309   done
14310 IFS=$as_save_IFS
14311 
14312   ;;
14313 esac
14314 fi
14315 DF=$ac_cv_path_DF
14316 if test -n "$DF"; then
14317   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14318 $as_echo "$DF" >&6; }
14319 else
14320   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14321 $as_echo "no" >&6; }
14322 fi
14323 
14324 
14325   test -n "$DF" && break
14326 done
14327 
14328     else
14329       # If it succeeded, then it was overridden by the user. We will use it
14330       # for the tool.
14331 
14332       # First remove it from the list of overridden variables, so we can test
14333       # for unknown variables in the end.
14334       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14335 
14336       # Check if we try to supply an empty value
14337       if test "x$DF" = x; then
14338         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
14339 $as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
14340         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14341 $as_echo_n "checking for DF... " >&6; }
14342         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14343 $as_echo "disabled" >&6; }
14344       else
14345         # Check if the provided tool contains a complete path.
14346         tool_specified="$DF"
14347         tool_basename="${tool_specified##*/}"
14348         if test "x$tool_basename" = "x$tool_specified"; then
14349           # A command without a complete path is provided, search $PATH.
14350           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
14351 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
14352           # Extract the first word of "$tool_basename", so it can be a program name with args.
14353 set dummy $tool_basename; ac_word=$2
14354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14355 $as_echo_n "checking for $ac_word... " >&6; }
14356 if ${ac_cv_path_DF+:} false; then :
14357   $as_echo_n "(cached) " >&6
14358 else
14359   case $DF in
14360   [\\/]* | ?:[\\/]*)
14361   ac_cv_path_DF="$DF" # Let the user override the test with a path.
14362   ;;
14363   *)
14364   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14365 for as_dir in $PATH
14366 do
14367   IFS=$as_save_IFS
14368   test -z "$as_dir" && as_dir=.
14369     for ac_exec_ext in '' $ac_executable_extensions; do
14370   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14371     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
14372     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14373     break 2
14374   fi
14375 done
14376   done
14377 IFS=$as_save_IFS
14378 
14379   ;;
14380 esac
14381 fi
14382 DF=$ac_cv_path_DF
14383 if test -n "$DF"; then
14384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
14385 $as_echo "$DF" >&6; }
14386 else
14387   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14388 $as_echo "no" >&6; }
14389 fi
14390 
14391 
14392           if test "x$DF" = x; then
14393             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14394           fi
14395         else
14396           # Otherwise we believe it is a complete path. Use it as it is.
14397           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
14398 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
14399           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
14400 $as_echo_n "checking for DF... " >&6; }
14401           if test ! -x "$tool_specified"; then
14402             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14403 $as_echo "not found" >&6; }
14404             as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
14405           fi
14406           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14407 $as_echo "$tool_specified" >&6; }
14408         fi
14409       fi
14410     fi
14411 
14412   fi
14413 
14414 
14415 
14416 
14417   # Publish this variable in the help.
14418 
14419 
14420   if [ -z "${CPIO+x}" ]; then
14421     # The variable is not set by user, try to locate tool using the code snippet
14422     for ac_prog in cpio bsdcpio
14423 do
14424   # Extract the first word of "$ac_prog", so it can be a program name with args.
14425 set dummy $ac_prog; ac_word=$2
14426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14427 $as_echo_n "checking for $ac_word... " >&6; }
14428 if ${ac_cv_path_CPIO+:} false; then :
14429   $as_echo_n "(cached) " >&6
14430 else
14431   case $CPIO in
14432   [\\/]* | ?:[\\/]*)
14433   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14434   ;;
14435   *)
14436   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14437 for as_dir in $PATH
14438 do
14439   IFS=$as_save_IFS
14440   test -z "$as_dir" && as_dir=.
14441     for ac_exec_ext in '' $ac_executable_extensions; do
14442   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14443     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14444     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14445     break 2
14446   fi
14447 done
14448   done
14449 IFS=$as_save_IFS
14450 
14451   ;;
14452 esac
14453 fi
14454 CPIO=$ac_cv_path_CPIO
14455 if test -n "$CPIO"; then
14456   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14457 $as_echo "$CPIO" >&6; }
14458 else
14459   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14460 $as_echo "no" >&6; }
14461 fi
14462 
14463 
14464   test -n "$CPIO" && break
14465 done
14466 
14467   else
14468     # The variable is set, but is it from the command line or the environment?
14469 
14470     # Try to remove the string !CPIO! from our list.
14471     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
14472     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14473       # If it failed, the variable was not from the command line. Ignore it,
14474       # but warn the user (except for BASH, which is always set by the calling BASH).
14475       if test "xCPIO" != xBASH; then
14476         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
14477 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
14478       fi
14479       # Try to locate tool using the code snippet
14480       for ac_prog in cpio bsdcpio
14481 do
14482   # Extract the first word of "$ac_prog", so it can be a program name with args.
14483 set dummy $ac_prog; ac_word=$2
14484 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14485 $as_echo_n "checking for $ac_word... " >&6; }
14486 if ${ac_cv_path_CPIO+:} false; then :
14487   $as_echo_n "(cached) " >&6
14488 else
14489   case $CPIO in
14490   [\\/]* | ?:[\\/]*)
14491   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14492   ;;
14493   *)
14494   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14495 for as_dir in $PATH
14496 do
14497   IFS=$as_save_IFS
14498   test -z "$as_dir" && as_dir=.
14499     for ac_exec_ext in '' $ac_executable_extensions; do
14500   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14501     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14502     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14503     break 2
14504   fi
14505 done
14506   done
14507 IFS=$as_save_IFS
14508 
14509   ;;
14510 esac
14511 fi
14512 CPIO=$ac_cv_path_CPIO
14513 if test -n "$CPIO"; then
14514   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14515 $as_echo "$CPIO" >&6; }
14516 else
14517   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14518 $as_echo "no" >&6; }
14519 fi
14520 
14521 
14522   test -n "$CPIO" && break
14523 done
14524 
14525     else
14526       # If it succeeded, then it was overridden by the user. We will use it
14527       # for the tool.
14528 
14529       # First remove it from the list of overridden variables, so we can test
14530       # for unknown variables in the end.
14531       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14532 
14533       # Check if we try to supply an empty value
14534       if test "x$CPIO" = x; then
14535         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
14536 $as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
14537         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14538 $as_echo_n "checking for CPIO... " >&6; }
14539         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14540 $as_echo "disabled" >&6; }
14541       else
14542         # Check if the provided tool contains a complete path.
14543         tool_specified="$CPIO"
14544         tool_basename="${tool_specified##*/}"
14545         if test "x$tool_basename" = "x$tool_specified"; then
14546           # A command without a complete path is provided, search $PATH.
14547           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
14548 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
14549           # Extract the first word of "$tool_basename", so it can be a program name with args.
14550 set dummy $tool_basename; ac_word=$2
14551 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14552 $as_echo_n "checking for $ac_word... " >&6; }
14553 if ${ac_cv_path_CPIO+:} false; then :
14554   $as_echo_n "(cached) " >&6
14555 else
14556   case $CPIO in
14557   [\\/]* | ?:[\\/]*)
14558   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
14559   ;;
14560   *)
14561   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14562 for as_dir in $PATH
14563 do
14564   IFS=$as_save_IFS
14565   test -z "$as_dir" && as_dir=.
14566     for ac_exec_ext in '' $ac_executable_extensions; do
14567   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14568     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
14569     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14570     break 2
14571   fi
14572 done
14573   done
14574 IFS=$as_save_IFS
14575 
14576   ;;
14577 esac
14578 fi
14579 CPIO=$ac_cv_path_CPIO
14580 if test -n "$CPIO"; then
14581   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
14582 $as_echo "$CPIO" >&6; }
14583 else
14584   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14585 $as_echo "no" >&6; }
14586 fi
14587 
14588 
14589           if test "x$CPIO" = x; then
14590             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14591           fi
14592         else
14593           # Otherwise we believe it is a complete path. Use it as it is.
14594           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
14595 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
14596           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
14597 $as_echo_n "checking for CPIO... " >&6; }
14598           if test ! -x "$tool_specified"; then
14599             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14600 $as_echo "not found" >&6; }
14601             as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
14602           fi
14603           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14604 $as_echo "$tool_specified" >&6; }
14605         fi
14606       fi
14607     fi
14608 
14609   fi
14610 
14611 
14612 
14613 
14614   # Publish this variable in the help.
14615 
14616 
14617   if [ -z "${NICE+x}" ]; then
14618     # The variable is not set by user, try to locate tool using the code snippet
14619     for ac_prog in nice
14620 do
14621   # Extract the first word of "$ac_prog", so it can be a program name with args.
14622 set dummy $ac_prog; ac_word=$2
14623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14624 $as_echo_n "checking for $ac_word... " >&6; }
14625 if ${ac_cv_path_NICE+:} false; then :
14626   $as_echo_n "(cached) " >&6
14627 else
14628   case $NICE in
14629   [\\/]* | ?:[\\/]*)
14630   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14631   ;;
14632   *)
14633   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14634 for as_dir in $PATH
14635 do
14636   IFS=$as_save_IFS
14637   test -z "$as_dir" && as_dir=.
14638     for ac_exec_ext in '' $ac_executable_extensions; do
14639   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14640     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14641     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14642     break 2
14643   fi
14644 done
14645   done
14646 IFS=$as_save_IFS
14647 
14648   ;;
14649 esac
14650 fi
14651 NICE=$ac_cv_path_NICE
14652 if test -n "$NICE"; then
14653   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14654 $as_echo "$NICE" >&6; }
14655 else
14656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14657 $as_echo "no" >&6; }
14658 fi
14659 
14660 
14661   test -n "$NICE" && break
14662 done
14663 
14664   else
14665     # The variable is set, but is it from the command line or the environment?
14666 
14667     # Try to remove the string !NICE! from our list.
14668     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
14669     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
14670       # If it failed, the variable was not from the command line. Ignore it,
14671       # but warn the user (except for BASH, which is always set by the calling BASH).
14672       if test "xNICE" != xBASH; then
14673         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
14674 $as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
14675       fi
14676       # Try to locate tool using the code snippet
14677       for ac_prog in nice
14678 do
14679   # Extract the first word of "$ac_prog", so it can be a program name with args.
14680 set dummy $ac_prog; ac_word=$2
14681 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14682 $as_echo_n "checking for $ac_word... " >&6; }
14683 if ${ac_cv_path_NICE+:} false; then :
14684   $as_echo_n "(cached) " >&6
14685 else
14686   case $NICE in
14687   [\\/]* | ?:[\\/]*)
14688   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14689   ;;
14690   *)
14691   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14692 for as_dir in $PATH
14693 do
14694   IFS=$as_save_IFS
14695   test -z "$as_dir" && as_dir=.
14696     for ac_exec_ext in '' $ac_executable_extensions; do
14697   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14698     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14699     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14700     break 2
14701   fi
14702 done
14703   done
14704 IFS=$as_save_IFS
14705 
14706   ;;
14707 esac
14708 fi
14709 NICE=$ac_cv_path_NICE
14710 if test -n "$NICE"; then
14711   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14712 $as_echo "$NICE" >&6; }
14713 else
14714   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14715 $as_echo "no" >&6; }
14716 fi
14717 
14718 
14719   test -n "$NICE" && break
14720 done
14721 
14722     else
14723       # If it succeeded, then it was overridden by the user. We will use it
14724       # for the tool.
14725 
14726       # First remove it from the list of overridden variables, so we can test
14727       # for unknown variables in the end.
14728       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
14729 
14730       # Check if we try to supply an empty value
14731       if test "x$NICE" = x; then
14732         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
14733 $as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
14734         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14735 $as_echo_n "checking for NICE... " >&6; }
14736         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
14737 $as_echo "disabled" >&6; }
14738       else
14739         # Check if the provided tool contains a complete path.
14740         tool_specified="$NICE"
14741         tool_basename="${tool_specified##*/}"
14742         if test "x$tool_basename" = "x$tool_specified"; then
14743           # A command without a complete path is provided, search $PATH.
14744           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
14745 $as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
14746           # Extract the first word of "$tool_basename", so it can be a program name with args.
14747 set dummy $tool_basename; ac_word=$2
14748 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14749 $as_echo_n "checking for $ac_word... " >&6; }
14750 if ${ac_cv_path_NICE+:} false; then :
14751   $as_echo_n "(cached) " >&6
14752 else
14753   case $NICE in
14754   [\\/]* | ?:[\\/]*)
14755   ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
14756   ;;
14757   *)
14758   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14759 for as_dir in $PATH
14760 do
14761   IFS=$as_save_IFS
14762   test -z "$as_dir" && as_dir=.
14763     for ac_exec_ext in '' $ac_executable_extensions; do
14764   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14765     ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
14766     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14767     break 2
14768   fi
14769 done
14770   done
14771 IFS=$as_save_IFS
14772 
14773   ;;
14774 esac
14775 fi
14776 NICE=$ac_cv_path_NICE
14777 if test -n "$NICE"; then
14778   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
14779 $as_echo "$NICE" >&6; }
14780 else
14781   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14782 $as_echo "no" >&6; }
14783 fi
14784 
14785 
14786           if test "x$NICE" = x; then
14787             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
14788           fi
14789         else
14790           # Otherwise we believe it is a complete path. Use it as it is.
14791           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
14792 $as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
14793           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
14794 $as_echo_n "checking for NICE... " >&6; }
14795           if test ! -x "$tool_specified"; then
14796             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
14797 $as_echo "not found" >&6; }
14798             as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
14799           fi
14800           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
14801 $as_echo "$tool_specified" >&6; }
14802         fi
14803       fi
14804     fi
14805 
14806   fi
14807 
14808 
14809 
14810 
14811 # Now we can determine OpenJDK build and target platforms. This is required to
14812 # have early on.
14813 # Make sure we can run config.sub.
14814 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
14815   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
14816 
14817 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
14818 $as_echo_n "checking build system type... " >&6; }
14819 if ${ac_cv_build+:} false; then :
14820   $as_echo_n "(cached) " >&6
14821 else
14822   ac_build_alias=$build_alias
14823 test "x$ac_build_alias" = x &&
14824   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
14825 test "x$ac_build_alias" = x &&
14826   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
14827 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
14828   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
14829 
14830 fi
14831 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
14832 $as_echo "$ac_cv_build" >&6; }
14833 case $ac_cv_build in
14834 *-*-*) ;;
14835 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
14836 esac
14837 build=$ac_cv_build
14838 ac_save_IFS=$IFS; IFS='-'
14839 set x $ac_cv_build
14840 shift
14841 build_cpu=$1
14842 build_vendor=$2
14843 shift; shift
14844 # Remember, the first character of IFS is used to create $*,
14845 # except with old shells:
14846 build_os=$*
14847 IFS=$ac_save_IFS
14848 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
14849 
14850 
14851 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
14852 $as_echo_n "checking host system type... " >&6; }
14853 if ${ac_cv_host+:} false; then :
14854   $as_echo_n "(cached) " >&6
14855 else
14856   if test "x$host_alias" = x; then
14857   ac_cv_host=$ac_cv_build
14858 else
14859   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
14860     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
14861 fi
14862 
14863 fi
14864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
14865 $as_echo "$ac_cv_host" >&6; }
14866 case $ac_cv_host in
14867 *-*-*) ;;
14868 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
14869 esac
14870 host=$ac_cv_host
14871 ac_save_IFS=$IFS; IFS='-'
14872 set x $ac_cv_host
14873 shift
14874 host_cpu=$1
14875 host_vendor=$2
14876 shift; shift
14877 # Remember, the first character of IFS is used to create $*,
14878 # except with old shells:
14879 host_os=$*
14880 IFS=$ac_save_IFS
14881 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
14882 
14883 
14884 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
14885 $as_echo_n "checking target system type... " >&6; }
14886 if ${ac_cv_target+:} false; then :
14887   $as_echo_n "(cached) " >&6
14888 else
14889   if test "x$target_alias" = x; then
14890   ac_cv_target=$ac_cv_host
14891 else
14892   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
14893     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
14894 fi
14895 
14896 fi
14897 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
14898 $as_echo "$ac_cv_target" >&6; }
14899 case $ac_cv_target in
14900 *-*-*) ;;
14901 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
14902 esac
14903 target=$ac_cv_target
14904 ac_save_IFS=$IFS; IFS='-'
14905 set x $ac_cv_target
14906 shift
14907 target_cpu=$1
14908 target_vendor=$2
14909 shift; shift
14910 # Remember, the first character of IFS is used to create $*,
14911 # except with old shells:
14912 target_os=$*
14913 IFS=$ac_save_IFS
14914 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
14915 
14916 
14917 # The aliases save the names the user supplied, while $host etc.
14918 # will get canonicalized.
14919 test -n "$target_alias" &&
14920   test "$program_prefix$program_suffix$program_transform_name" = \
14921     NONENONEs,x,x, &&
14922   program_prefix=${target_alias}-
14923 
14924   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
14925   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
14926   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
14927   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
14928   # to use the configure naming style.
14929 
14930 
14931 
14932 
14933 
14934   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
14935   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
14936   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
14937   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
14938   OPENJDK_TARGET_AUTOCONF_NAME="$host"
14939   OPENJDK_BUILD_AUTOCONF_NAME="$build"
14940 
14941 
14942 
14943   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
14944 
14945   case "$build_os" in
14946     *linux*)
14947       VAR_OS=linux
14948       VAR_OS_TYPE=unix
14949       ;;
14950     *solaris*)
14951       VAR_OS=solaris
14952       VAR_OS_TYPE=unix
14953       ;;
14954     *darwin*)
14955       VAR_OS=macosx
14956       VAR_OS_TYPE=unix
14957       ;;
14958     *bsd*)
14959       VAR_OS=bsd
14960       VAR_OS_TYPE=unix
14961       ;;
14962     *cygwin*)
14963       VAR_OS=windows
14964       VAR_OS_ENV=windows.cygwin
14965       ;;
14966     *mingw*)
14967       VAR_OS=windows
14968       VAR_OS_ENV=windows.msys
14969       ;;
14970     *aix*)
14971       VAR_OS=aix
14972       VAR_OS_TYPE=unix
14973       ;;
14974     *)
14975       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
14976       ;;
14977   esac
14978 
14979 
14980   # First argument is the cpu name from the trip/quad
14981   case "$build_cpu" in
14982     x86_64)
14983       VAR_CPU=x86_64
14984       VAR_CPU_ARCH=x86
14985       VAR_CPU_BITS=64
14986       VAR_CPU_ENDIAN=little
14987       ;;
14988     i?86)
14989       VAR_CPU=x86
14990       VAR_CPU_ARCH=x86
14991       VAR_CPU_BITS=32
14992       VAR_CPU_ENDIAN=little
14993       ;;
14994     arm*)
14995       VAR_CPU=arm
14996       VAR_CPU_ARCH=arm
14997       VAR_CPU_BITS=32
14998       VAR_CPU_ENDIAN=little
14999       ;;
15000     aarch64)
15001       VAR_CPU=aarch64
15002       VAR_CPU_ARCH=aarch64
15003       VAR_CPU_BITS=64
15004       VAR_CPU_ENDIAN=little
15005       ;;
15006     powerpc)
15007       VAR_CPU=ppc
15008       VAR_CPU_ARCH=ppc
15009       VAR_CPU_BITS=32
15010       VAR_CPU_ENDIAN=big
15011       ;;
15012     powerpc64)
15013       VAR_CPU=ppc64
15014       VAR_CPU_ARCH=ppc
15015       VAR_CPU_BITS=64
15016       VAR_CPU_ENDIAN=big
15017       ;;
15018     powerpc64le)
15019       VAR_CPU=ppc64le
15020       VAR_CPU_ARCH=ppc
15021       VAR_CPU_BITS=64
15022       VAR_CPU_ENDIAN=little
15023       ;;
15024     s390)
15025       VAR_CPU=s390
15026       VAR_CPU_ARCH=s390
15027       VAR_CPU_BITS=32
15028       VAR_CPU_ENDIAN=big
15029       ;;
15030     s390x)
15031       VAR_CPU=s390x
15032       VAR_CPU_ARCH=s390
15033       VAR_CPU_BITS=64
15034       VAR_CPU_ENDIAN=big
15035       ;;
15036     sparc)
15037       VAR_CPU=sparc
15038       VAR_CPU_ARCH=sparc
15039       VAR_CPU_BITS=32
15040       VAR_CPU_ENDIAN=big
15041       ;;
15042     sparcv9|sparc64)
15043       VAR_CPU=sparcv9
15044       VAR_CPU_ARCH=sparc
15045       VAR_CPU_BITS=64
15046       VAR_CPU_ENDIAN=big
15047       ;;
15048     *)
15049       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
15050       ;;
15051   esac
15052 
15053   # ..and setup our own variables. (Do this explicitely to facilitate searching)
15054   OPENJDK_BUILD_OS="$VAR_OS"
15055   if test "x$VAR_OS_TYPE" != x; then
15056     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
15057   else
15058     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
15059   fi
15060   if test "x$VAR_OS_ENV" != x; then
15061     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
15062   else
15063     OPENJDK_BUILD_OS_ENV="$VAR_OS"
15064   fi
15065   OPENJDK_BUILD_CPU="$VAR_CPU"
15066   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
15067   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
15068   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15069 
15070 
15071 
15072 
15073 
15074 
15075 
15076 
15077   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
15078 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
15079   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
15080 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
15081 
15082   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
15083 
15084   case "$host_os" in
15085     *linux*)
15086       VAR_OS=linux
15087       VAR_OS_TYPE=unix
15088       ;;
15089     *solaris*)
15090       VAR_OS=solaris
15091       VAR_OS_TYPE=unix
15092       ;;
15093     *darwin*)
15094       VAR_OS=macosx
15095       VAR_OS_TYPE=unix
15096       ;;
15097     *bsd*)
15098       VAR_OS=bsd
15099       VAR_OS_TYPE=unix
15100       ;;
15101     *cygwin*)
15102       VAR_OS=windows
15103       VAR_OS_ENV=windows.cygwin
15104       ;;
15105     *mingw*)
15106       VAR_OS=windows
15107       VAR_OS_ENV=windows.msys
15108       ;;
15109     *aix*)
15110       VAR_OS=aix
15111       VAR_OS_TYPE=unix
15112       ;;
15113     *)
15114       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
15115       ;;
15116   esac
15117 
15118 
15119   # First argument is the cpu name from the trip/quad
15120   case "$host_cpu" in
15121     x86_64)
15122       VAR_CPU=x86_64
15123       VAR_CPU_ARCH=x86
15124       VAR_CPU_BITS=64
15125       VAR_CPU_ENDIAN=little
15126       ;;
15127     i?86)
15128       VAR_CPU=x86
15129       VAR_CPU_ARCH=x86
15130       VAR_CPU_BITS=32
15131       VAR_CPU_ENDIAN=little
15132       ;;
15133     arm*)
15134       VAR_CPU=arm
15135       VAR_CPU_ARCH=arm
15136       VAR_CPU_BITS=32
15137       VAR_CPU_ENDIAN=little
15138       ;;
15139     aarch64)
15140       VAR_CPU=aarch64
15141       VAR_CPU_ARCH=aarch64
15142       VAR_CPU_BITS=64
15143       VAR_CPU_ENDIAN=little
15144       ;;
15145     powerpc)
15146       VAR_CPU=ppc
15147       VAR_CPU_ARCH=ppc
15148       VAR_CPU_BITS=32
15149       VAR_CPU_ENDIAN=big
15150       ;;
15151     powerpc64)
15152       VAR_CPU=ppc64
15153       VAR_CPU_ARCH=ppc
15154       VAR_CPU_BITS=64
15155       VAR_CPU_ENDIAN=big
15156       ;;
15157     powerpc64le)
15158       VAR_CPU=ppc64le
15159       VAR_CPU_ARCH=ppc
15160       VAR_CPU_BITS=64
15161       VAR_CPU_ENDIAN=little
15162       ;;
15163     s390)
15164       VAR_CPU=s390
15165       VAR_CPU_ARCH=s390
15166       VAR_CPU_BITS=32
15167       VAR_CPU_ENDIAN=big
15168       ;;
15169     s390x)
15170       VAR_CPU=s390x
15171       VAR_CPU_ARCH=s390
15172       VAR_CPU_BITS=64
15173       VAR_CPU_ENDIAN=big
15174       ;;
15175     sparc)
15176       VAR_CPU=sparc
15177       VAR_CPU_ARCH=sparc
15178       VAR_CPU_BITS=32
15179       VAR_CPU_ENDIAN=big
15180       ;;
15181     sparcv9|sparc64)
15182       VAR_CPU=sparcv9
15183       VAR_CPU_ARCH=sparc
15184       VAR_CPU_BITS=64
15185       VAR_CPU_ENDIAN=big
15186       ;;
15187     *)
15188       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
15189       ;;
15190   esac
15191 
15192   # ... and setup our own variables. (Do this explicitely to facilitate searching)
15193   OPENJDK_TARGET_OS="$VAR_OS"
15194   if test "x$VAR_OS_TYPE" != x; then
15195     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
15196   else
15197     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
15198   fi
15199   if test "x$VAR_OS_ENV" != x; then
15200     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
15201   else
15202     OPENJDK_TARGET_OS_ENV="$VAR_OS"
15203   fi
15204   OPENJDK_TARGET_CPU="$VAR_CPU"
15205   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
15206   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
15207   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
15208 
15209 
15210 
15211 
15212 
15213 
15214 
15215 
15216   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
15217 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
15218   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
15219 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
15220 
15221 
15222 
15223 # Check whether --with-target-bits was given.
15224 if test "${with_target_bits+set}" = set; then :
15225   withval=$with_target_bits;
15226 fi
15227 
15228 
15229   # We have three types of compiles:
15230   # native  == normal compilation, target system == build system
15231   # cross   == traditional cross compilation, target system != build system; special toolchain needed
15232   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
15233   #
15234   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
15235     # We're doing a proper cross-compilation
15236     COMPILE_TYPE="cross"
15237   else
15238     COMPILE_TYPE="native"
15239   fi
15240 
15241   if test "x$with_target_bits" != x; then
15242     if test "x$COMPILE_TYPE" = "xcross"; then
15243       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
15244     fi
15245 
15246     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15247       # A reduced build is requested
15248       COMPILE_TYPE="reduced"
15249       OPENJDK_TARGET_CPU_BITS=32
15250       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
15251         OPENJDK_TARGET_CPU=x86
15252       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
15253         OPENJDK_TARGET_CPU=sparc
15254       else
15255         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
15256       fi
15257     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
15258       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
15259     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
15260       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
15261 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
15262     else
15263       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
15264     fi
15265   fi
15266 
15267 
15268   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
15269 $as_echo_n "checking compilation type... " >&6; }
15270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
15271 $as_echo "$COMPILE_TYPE" >&6; }
15272 
15273 
15274   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
15275     REQUIRED_OS_NAME=SunOS
15276     REQUIRED_OS_VERSION=5.10
15277   fi
15278   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
15279     REQUIRED_OS_NAME=Linux
15280     REQUIRED_OS_VERSION=2.6
15281   fi
15282   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15283     REQUIRED_OS_NAME=Windows
15284     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
15285       REQUIRED_OS_VERSION=5.2
15286     else
15287       REQUIRED_OS_VERSION=5.1
15288     fi
15289   fi
15290   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
15291     REQUIRED_OS_NAME=Darwin
15292     REQUIRED_OS_VERSION=11.2
15293   fi
15294   if test "x$OPENJDK_TARGET_OS" = "xaix"; then
15295     REQUIRED_OS_NAME=AIX
15296     REQUIRED_OS_VERSION=7.1
15297   fi
15298 
15299 
15300 
15301 
15302 
15303 
15304   # Also store the legacy naming of the cpu.
15305   # Ie i586 and amd64 instead of x86 and x86_64
15306   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
15307   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15308     OPENJDK_TARGET_CPU_LEGACY="i586"
15309   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15310     # On all platforms except MacOSX replace x86_64 with amd64.
15311     OPENJDK_TARGET_CPU_LEGACY="amd64"
15312   fi
15313 
15314 
15315   # And the second legacy naming of the cpu.
15316   # Ie i386 and amd64 instead of x86 and x86_64.
15317   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
15318   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15319     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
15320   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15321     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
15322   fi
15323 
15324 
15325   # This is the name of the cpu (but using i386 and amd64 instead of
15326   # x86 and x86_64, respectively), preceeded by a /, to be used when
15327   # locating libraries. On macosx, it's empty, though.
15328   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
15329   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15330     OPENJDK_TARGET_CPU_LIBDIR=""
15331   fi
15332 
15333 
15334   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15335   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15336   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
15337   OPENJDK_TARGET_CPU_ISADIR=""
15338   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15339     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15340       OPENJDK_TARGET_CPU_ISADIR="/amd64"
15341     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15342       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
15343     fi
15344   fi
15345 
15346 
15347   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
15348   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
15349   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
15350     # On linux only, we replace x86 with i386.
15351     OPENJDK_TARGET_CPU_OSARCH="i386"
15352   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15353     # On all platforms except macosx, we replace x86_64 with amd64.
15354     OPENJDK_TARGET_CPU_OSARCH="amd64"
15355   fi
15356 
15357 
15358   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
15359   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15360     OPENJDK_TARGET_CPU_JLI="i386"
15361   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15362     # On all platforms except macosx, we replace x86_64 with amd64.
15363     OPENJDK_TARGET_CPU_JLI="amd64"
15364   fi
15365   # Now setup the -D flags for building libjli.
15366   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
15367   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
15368     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
15369       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15370     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
15371       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15372     fi
15373   fi
15374 
15375 
15376   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15377       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
15378   else
15379       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
15380   fi
15381 
15382 
15383   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15384     A_LP64="LP64:="
15385     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15386     # unpack200.exe
15387     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
15388       OPENJDK_TARGET_ADD_LP64="-D_LP64=1"
15389     fi
15390   fi
15391   LP64=$A_LP64
15392 
15393 
15394   if test "x$COMPILE_TYPE" = "xcross"; then
15395     # FIXME: ... or should this include reduced builds..?
15396     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
15397   else
15398     DEFINE_CROSS_COMPILE_ARCH=""
15399   fi
15400 
15401 
15402   # Convert openjdk platform names to hotspot names
15403 
15404   HOTSPOT_TARGET_OS=${OPENJDK_TARGET_OS}
15405   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
15406     HOTSPOT_TARGET_OS=bsd
15407   fi
15408 
15409 
15410   HOTSPOT_TARGET_OS_TYPE=${OPENJDK_TARGET_OS_TYPE}
15411   if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
15412     HOTSPOT_TARGET_OS_TYPE=posix
15413   fi
15414 
15415 
15416   HOTSPOT_TARGET_CPU=${OPENJDK_TARGET_CPU}
15417   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15418     HOTSPOT_TARGET_CPU=x86_32
15419   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15420     HOTSPOT_TARGET_CPU=sparc
15421   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15422     HOTSPOT_TARGET_CPU=ppc_64
15423   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15424     HOTSPOT_TARGET_CPU=ppc_64
15425   fi
15426 
15427 
15428   # This is identical with OPENJDK_*, but define anyway for consistency.
15429   HOTSPOT_TARGET_CPU_ARCH=${OPENJDK_TARGET_CPU_ARCH}
15430 
15431 
15432   # Setup HOTSPOT_TARGET_CPU_DEFINE
15433   if test "x$OPENJDK_TARGET_CPU" = xx86; then
15434     HOTSPOT_TARGET_CPU_DEFINE=IA32
15435   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
15436     HOTSPOT_TARGET_CPU_DEFINE=AMD64
15437   elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
15438     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15439   elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then
15440     HOTSPOT_TARGET_CPU_DEFINE=AARCH64
15441   elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
15442     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15443   elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
15444     HOTSPOT_TARGET_CPU_DEFINE=PPC64
15445 
15446   # The cpu defines below are for zero, we don't support them directly.
15447   elif test "x$OPENJDK_TARGET_CPU" = xsparc; then
15448     HOTSPOT_TARGET_CPU_DEFINE=SPARC
15449   elif test "x$OPENJDK_TARGET_CPU" = xppc; then
15450     HOTSPOT_TARGET_CPU_DEFINE=PPC32
15451   elif test "x$OPENJDK_TARGET_CPU" = xs390; then
15452     HOTSPOT_TARGET_CPU_DEFINE=S390
15453   elif test "x$OPENJDK_TARGET_CPU" = ss390x; then
15454     HOTSPOT_TARGET_CPU_DEFINE=S390
15455   fi
15456 
15457 
15458 
15459 
15460   # Also store the legacy naming of the cpu.
15461   # Ie i586 and amd64 instead of x86 and x86_64
15462   OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
15463   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15464     OPENJDK_BUILD_CPU_LEGACY="i586"
15465   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15466     # On all platforms except MacOSX replace x86_64 with amd64.
15467     OPENJDK_BUILD_CPU_LEGACY="amd64"
15468   fi
15469 
15470 
15471   # And the second legacy naming of the cpu.
15472   # Ie i386 and amd64 instead of x86 and x86_64.
15473   OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
15474   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15475     OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
15476   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15477     OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
15478   fi
15479 
15480 
15481   # This is the name of the cpu (but using i386 and amd64 instead of
15482   # x86 and x86_64, respectively), preceeded by a /, to be used when
15483   # locating libraries. On macosx, it's empty, though.
15484   OPENJDK_BUILD_CPU_LIBDIR="/$OPENJDK_BUILD_CPU_LEGACY_LIB"
15485   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15486     OPENJDK_BUILD_CPU_LIBDIR=""
15487   fi
15488 
15489 
15490   # OPENJDK_BUILD_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
15491   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
15492   # /usr/lib${OPENJDK_BUILD_CPU_ISADIR}/libexample.so
15493   OPENJDK_BUILD_CPU_ISADIR=""
15494   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15495     if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15496       OPENJDK_BUILD_CPU_ISADIR="/amd64"
15497     elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15498       OPENJDK_BUILD_CPU_ISADIR="/sparcv9"
15499     fi
15500   fi
15501 
15502 
15503   # Setup OPENJDK_BUILD_CPU_OSARCH, which is used to set the os.arch Java system property
15504   OPENJDK_BUILD_CPU_OSARCH="$OPENJDK_BUILD_CPU"
15505   if test "x$OPENJDK_BUILD_OS" = xlinux && test "x$OPENJDK_BUILD_CPU" = xx86; then
15506     # On linux only, we replace x86 with i386.
15507     OPENJDK_BUILD_CPU_OSARCH="i386"
15508   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15509     # On all platforms except macosx, we replace x86_64 with amd64.
15510     OPENJDK_BUILD_CPU_OSARCH="amd64"
15511   fi
15512 
15513 
15514   OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
15515   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15516     OPENJDK_BUILD_CPU_JLI="i386"
15517   elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15518     # On all platforms except macosx, we replace x86_64 with amd64.
15519     OPENJDK_BUILD_CPU_JLI="amd64"
15520   fi
15521   # Now setup the -D flags for building libjli.
15522   OPENJDK_BUILD_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_BUILD_CPU_JLI\"'"
15523   if test "x$OPENJDK_BUILD_OS" = xsolaris; then
15524     if test "x$OPENJDK_BUILD_CPU_ARCH" = xsparc; then
15525       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
15526     elif test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
15527       OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
15528     fi
15529   fi
15530 
15531 
15532   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15533       OPENJDK_BUILD_OS_EXPORT_DIR=macosx
15534   else
15535       OPENJDK_BUILD_OS_EXPORT_DIR=${OPENJDK_BUILD_OS_TYPE}
15536   fi
15537 
15538 
15539   if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
15540     A_LP64="LP64:="
15541     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
15542     # unpack200.exe
15543     if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
15544       OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
15545     fi
15546   fi
15547   LP64=$A_LP64
15548 
15549 
15550   if test "x$COMPILE_TYPE" = "xcross"; then
15551     # FIXME: ... or should this include reduced builds..?
15552     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_BUILD_CPU_LEGACY"
15553   else
15554     DEFINE_CROSS_COMPILE_ARCH=""
15555   fi
15556 
15557 
15558   # Convert openjdk platform names to hotspot names
15559 
15560   HOTSPOT_BUILD_OS=${OPENJDK_BUILD_OS}
15561   if test "x$OPENJDK_BUILD_OS" = xmacosx; then
15562     HOTSPOT_BUILD_OS=bsd
15563   fi
15564 
15565 
15566   HOTSPOT_BUILD_OS_TYPE=${OPENJDK_BUILD_OS_TYPE}
15567   if test "x$OPENJDK_BUILD_OS_TYPE" = xunix; then
15568     HOTSPOT_BUILD_OS_TYPE=posix
15569   fi
15570 
15571 
15572   HOTSPOT_BUILD_CPU=${OPENJDK_BUILD_CPU}
15573   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15574     HOTSPOT_BUILD_CPU=x86_32
15575   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15576     HOTSPOT_BUILD_CPU=sparc
15577   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
15578     HOTSPOT_BUILD_CPU=ppc_64
15579   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
15580     HOTSPOT_BUILD_CPU=ppc_64
15581   fi
15582 
15583 
15584   # This is identical with OPENJDK_*, but define anyway for consistency.
15585   HOTSPOT_BUILD_CPU_ARCH=${OPENJDK_BUILD_CPU_ARCH}
15586 
15587 
15588   # Setup HOTSPOT_BUILD_CPU_DEFINE
15589   if test "x$OPENJDK_BUILD_CPU" = xx86; then
15590     HOTSPOT_BUILD_CPU_DEFINE=IA32
15591   elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
15592     HOTSPOT_BUILD_CPU_DEFINE=AMD64
15593   elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
15594     HOTSPOT_BUILD_CPU_DEFINE=SPARC
15595   elif test "x$OPENJDK_BUILD_CPU" = xaarch64; then
15596     HOTSPOT_BUILD_CPU_DEFINE=AARCH64
15597   elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
15598     HOTSPOT_BUILD_CPU_DEFINE=PPC64
15599   elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
15600     HOTSPOT_BUILD_CPU_DEFINE=PPC64
15601 
15602   # The cpu defines below are for zero, we don't support them directly.
15603   elif test "x$OPENJDK_BUILD_CPU" = xsparc; then
15604     HOTSPOT_BUILD_CPU_DEFINE=SPARC
15605   elif test "x$OPENJDK_BUILD_CPU" = xppc; then
15606     HOTSPOT_BUILD_CPU_DEFINE=PPC32
15607   elif test "x$OPENJDK_BUILD_CPU" = xs390; then
15608     HOTSPOT_BUILD_CPU_DEFINE=S390
15609   elif test "x$OPENJDK_BUILD_CPU" = ss390x; then
15610     HOTSPOT_BUILD_CPU_DEFINE=S390
15611   fi
15612 
15613 
15614 
15615 
15616   # ZERO_ARCHDEF is used to enable architecture-specific code.
15617   # This is used in legacy hotspot build.
15618   ZERO_ARCHDEF="$HOTSPOT_TARGET_CPU_DEFINE"
15619 
15620 
15621 
15622 
15623 
15624 # Continue setting up basic stuff. Most remaining code require fundamental tools.
15625 
15626   # Save the current directory this script was started from
15627   CURDIR="$PWD"
15628 
15629   # We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
15630   # for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
15631   # was not available at that time.
15632   REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
15633   if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
15634     ORIGINAL_PATH="$REWRITTEN_PATH"
15635     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
15636 $as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
15637   fi
15638 
15639   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
15640     PATH_SEP=";"
15641 
15642   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
15643   if test $SRC_ROOT_LENGTH -gt 100; then
15644     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
15645   fi
15646 
15647   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15648     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
15649 $as_echo_n "checking cygwin release... " >&6; }
15650     CYGWIN_VERSION=`$UNAME -r`
15651     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
15652 $as_echo "$CYGWIN_VERSION" >&6; }
15653     WINDOWS_ENV_VENDOR='cygwin'
15654     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
15655 
15656     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
15657     if test "x$CYGWIN_VERSION_OLD" != x; then
15658       { $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
15659 $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;}
15660       as_fn_error $? "Cannot continue" "$LINENO" 5
15661     fi
15662     if test "x$CYGPATH" = x; then
15663       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
15664     fi
15665     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
15666 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
15667     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15668     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
15669     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
15670     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
15671     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
15672 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
15673     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
15674     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
15675     if test "x$test_cygdrive_prefix" = x; then
15676       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
15677     fi
15678   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15679     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
15680 $as_echo_n "checking msys release... " >&6; }
15681     MSYS_VERSION=`$UNAME -r`
15682     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
15683 $as_echo "$MSYS_VERSION" >&6; }
15684 
15685     WINDOWS_ENV_VENDOR='msys'
15686     WINDOWS_ENV_VERSION="$MSYS_VERSION"
15687 
15688     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
15689 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
15690     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
15691     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
15692 
15693   windows_path="$MSYS_ROOT_PATH"
15694   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15695     unix_path=`$CYGPATH -u "$windows_path"`
15696     MSYS_ROOT_PATH="$unix_path"
15697   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15698     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15699     MSYS_ROOT_PATH="$unix_path"
15700   fi
15701 
15702     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
15703 $as_echo "$MSYS_ROOT_PATH" >&6; }
15704     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
15705   else
15706     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
15707   fi
15708 
15709   # Test if windows or unix (cygwin/msys) find is first in path.
15710   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
15711 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
15712   FIND_BINARY_OUTPUT=`find --version 2>&1`
15713   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
15714     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
15715 $as_echo "unix style" >&6; }
15716   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
15717     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
15718 $as_echo "Windows" >&6; }
15719     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
15720 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
15721     { $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
15722 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
15723     as_fn_error $? "Cannot continue" "$LINENO" 5
15724   else
15725     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
15726 $as_echo "unknown" >&6; }
15727     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
15728 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
15729   fi
15730 
15731   else
15732     PATH_SEP=":"
15733   fi
15734 
15735 
15736   # We get the top-level directory from the supporting wrappers.
15737   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
15738 $as_echo_n "checking for top-level directory... " >&6; }
15739   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
15740 $as_echo "$TOPDIR" >&6; }
15741 
15742 
15743   # Save the original version of TOPDIR for string comparisons
15744   ORIGINAL_TOPDIR="$TOPDIR"
15745 
15746 
15747   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
15748 
15749   # Only process if variable expands to non-empty
15750 
15751   if test "x$CURDIR" != x; then
15752     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15753 
15754   # Input might be given as Windows format, start by converting to
15755   # unix format.
15756   path="$CURDIR"
15757   new_path=`$CYGPATH -u "$path"`
15758 
15759   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15760   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15761   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15762   # "foo.exe" is OK but "foo" is an error.
15763   #
15764   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15765   # It is also a way to make sure we got the proper file name for the real test later on.
15766   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15767   if test "x$test_shortpath" = x; then
15768     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15769 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15770     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
15771   fi
15772 
15773   # Call helper function which possibly converts this using DOS-style short mode.
15774   # If so, the updated path is stored in $new_path.
15775 
15776   input_path="$new_path"
15777   # Check if we need to convert this using DOS-style short mode. If the path
15778   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15779   # take no chances and rewrite it.
15780   # Note: m4 eats our [], so we need to use [ and ] instead.
15781   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15782   if test "x$has_forbidden_chars" != x; then
15783     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15784     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15785     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15786     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15787       # Going to short mode and back again did indeed matter. Since short mode is
15788       # case insensitive, let's make it lowercase to improve readability.
15789       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15790       # Now convert it back to Unix-style (cygpath)
15791       input_path=`$CYGPATH -u "$shortmode_path"`
15792       new_path="$input_path"
15793     fi
15794   fi
15795 
15796   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15797   if test "x$test_cygdrive_prefix" = x; then
15798     # As a simple fix, exclude /usr/bin since it's not a real path.
15799     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15800       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15801       # a path prefixed by /cygdrive for fixpath to work.
15802       new_path="$CYGWIN_ROOT_PATH$input_path"
15803     fi
15804   fi
15805 
15806 
15807   if test "x$path" != "x$new_path"; then
15808     CURDIR="$new_path"
15809     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15810 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15811   fi
15812 
15813     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15814 
15815   path="$CURDIR"
15816   has_colon=`$ECHO $path | $GREP ^.:`
15817   new_path="$path"
15818   if test "x$has_colon" = x; then
15819     # Not in mixed or Windows style, start by that.
15820     new_path=`cmd //c echo $path`
15821   fi
15822 
15823 
15824   input_path="$new_path"
15825   # Check if we need to convert this using DOS-style short mode. If the path
15826   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15827   # take no chances and rewrite it.
15828   # Note: m4 eats our [], so we need to use [ and ] instead.
15829   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15830   if test "x$has_forbidden_chars" != x; then
15831     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15832     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15833   fi
15834 
15835 
15836   windows_path="$new_path"
15837   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15838     unix_path=`$CYGPATH -u "$windows_path"`
15839     new_path="$unix_path"
15840   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15841     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15842     new_path="$unix_path"
15843   fi
15844 
15845   if test "x$path" != "x$new_path"; then
15846     CURDIR="$new_path"
15847     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
15848 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
15849   fi
15850 
15851   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15852   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15853 
15854     else
15855       # We're on a unix platform. Hooray! :)
15856       path="$CURDIR"
15857       has_space=`$ECHO "$path" | $GREP " "`
15858       if test "x$has_space" != x; then
15859         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
15860 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
15861         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15862       fi
15863 
15864       # Use eval to expand a potential ~
15865       eval path="$path"
15866       if test ! -f "$path" && test ! -d "$path"; then
15867         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
15868       fi
15869 
15870       if test -d "$path"; then
15871         CURDIR="`cd "$path"; $THEPWDCMD -L`"
15872       else
15873         dir="`$DIRNAME "$path"`"
15874         base="`$BASENAME "$path"`"
15875         CURDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
15876       fi
15877     fi
15878   fi
15879 
15880 
15881   # Only process if variable expands to non-empty
15882 
15883   if test "x$TOPDIR" != x; then
15884     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15885 
15886   # Input might be given as Windows format, start by converting to
15887   # unix format.
15888   path="$TOPDIR"
15889   new_path=`$CYGPATH -u "$path"`
15890 
15891   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15892   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15893   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15894   # "foo.exe" is OK but "foo" is an error.
15895   #
15896   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15897   # It is also a way to make sure we got the proper file name for the real test later on.
15898   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15899   if test "x$test_shortpath" = x; then
15900     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15901 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15902     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
15903   fi
15904 
15905   # Call helper function which possibly converts this using DOS-style short mode.
15906   # If so, the updated path is stored in $new_path.
15907 
15908   input_path="$new_path"
15909   # Check if we need to convert this using DOS-style short mode. If the path
15910   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15911   # take no chances and rewrite it.
15912   # Note: m4 eats our [], so we need to use [ and ] instead.
15913   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15914   if test "x$has_forbidden_chars" != x; then
15915     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15916     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15917     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15918     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15919       # Going to short mode and back again did indeed matter. Since short mode is
15920       # case insensitive, let's make it lowercase to improve readability.
15921       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15922       # Now convert it back to Unix-style (cygpath)
15923       input_path=`$CYGPATH -u "$shortmode_path"`
15924       new_path="$input_path"
15925     fi
15926   fi
15927 
15928   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15929   if test "x$test_cygdrive_prefix" = x; then
15930     # As a simple fix, exclude /usr/bin since it's not a real path.
15931     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15932       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15933       # a path prefixed by /cygdrive for fixpath to work.
15934       new_path="$CYGWIN_ROOT_PATH$input_path"
15935     fi
15936   fi
15937 
15938 
15939   if test "x$path" != "x$new_path"; then
15940     TOPDIR="$new_path"
15941     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15942 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15943   fi
15944 
15945     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15946 
15947   path="$TOPDIR"
15948   has_colon=`$ECHO $path | $GREP ^.:`
15949   new_path="$path"
15950   if test "x$has_colon" = x; then
15951     # Not in mixed or Windows style, start by that.
15952     new_path=`cmd //c echo $path`
15953   fi
15954 
15955 
15956   input_path="$new_path"
15957   # Check if we need to convert this using DOS-style short mode. If the path
15958   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15959   # take no chances and rewrite it.
15960   # Note: m4 eats our [], so we need to use [ and ] instead.
15961   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15962   if test "x$has_forbidden_chars" != x; then
15963     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15964     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15965   fi
15966 
15967 
15968   windows_path="$new_path"
15969   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15970     unix_path=`$CYGPATH -u "$windows_path"`
15971     new_path="$unix_path"
15972   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15973     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15974     new_path="$unix_path"
15975   fi
15976 
15977   if test "x$path" != "x$new_path"; then
15978     TOPDIR="$new_path"
15979     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
15980 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
15981   fi
15982 
15983   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15984   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15985 
15986     else
15987       # We're on a unix platform. Hooray! :)
15988       path="$TOPDIR"
15989       has_space=`$ECHO "$path" | $GREP " "`
15990       if test "x$has_space" != x; then
15991         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
15992 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
15993         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15994       fi
15995 
15996       # Use eval to expand a potential ~
15997       eval path="$path"
15998       if test ! -f "$path" && test ! -d "$path"; then
15999         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
16000       fi
16001 
16002       if test -d "$path"; then
16003         TOPDIR="`cd "$path"; $THEPWDCMD -L`"
16004       else
16005         dir="`$DIRNAME "$path"`"
16006         base="`$BASENAME "$path"`"
16007         TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
16008       fi
16009     fi
16010   fi
16011 
16012   # SRC_ROOT is a traditional alias for TOPDIR.
16013   SRC_ROOT=$TOPDIR
16014 
16015   # Calculate a canonical version of TOPDIR for string comparisons
16016   CANONICAL_TOPDIR=$TOPDIR
16017 
16018   if test "x$OPENJDK_BUILD_OS" != xwindows; then
16019     # Follow a chain of symbolic links. Use readlink
16020     # where it exists, else fall back to horribly
16021     # complicated shell code.
16022     if test "x$READLINK_TESTED" != yes; then
16023       # On MacOSX there is a readlink tool with a different
16024       # purpose than the GNU readlink tool. Check the found readlink.
16025       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
16026       if test "x$ISGNU" = x; then
16027         # A readlink that we do not know how to use.
16028         # Are there other non-GNU readlinks out there?
16029         READLINK_TESTED=yes
16030         READLINK=
16031       fi
16032     fi
16033 
16034     if test "x$READLINK" != x; then
16035       CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
16036     else
16037       # Save the current directory for restoring afterwards
16038       STARTDIR=$PWD
16039       COUNTER=0
16040       sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
16041       sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
16042       cd $sym_link_dir
16043       # Use -P flag to resolve symlinks in directories.
16044       cd `$THEPWDCMD -P`
16045       sym_link_dir=`$THEPWDCMD -P`
16046       # Resolve file symlinks
16047       while test $COUNTER -lt 20; do
16048         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
16049         if test "x$ISLINK" == x; then
16050           # This is not a symbolic link! We are done!
16051           break
16052         fi
16053         # Again resolve directory symlinks since the target of the just found
16054         # link could be in a different directory
16055         cd `$DIRNAME $ISLINK`
16056         sym_link_dir=`$THEPWDCMD -P`
16057         sym_link_file=`$BASENAME $ISLINK`
16058         let COUNTER=COUNTER+1
16059       done
16060       cd $STARTDIR
16061       CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
16062     fi
16063   fi
16064 
16065 
16066 
16067   # Locate the directory of this script.
16068   AUTOCONF_DIR=$TOPDIR/common/autoconf
16069 
16070   # Setup username (for use in adhoc version strings etc)
16071   # Outer [ ] to quote m4.
16072    USERNAME=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
16073 
16074 
16075 
16076 # Check if it's a pure open build or if custom sources are to be used.
16077 
16078   # Check whether --enable-openjdk-only was given.
16079 if test "${enable_openjdk_only+set}" = set; then :
16080   enableval=$enable_openjdk_only;
16081 else
16082   enable_openjdk_only="no"
16083 fi
16084 
16085 
16086   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
16087 $as_echo_n "checking for presence of closed sources... " >&6; }
16088   if test -d "$SRC_ROOT/jdk/src/closed"; then
16089     CLOSED_SOURCE_PRESENT=yes
16090   else
16091     CLOSED_SOURCE_PRESENT=no
16092   fi
16093   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
16094 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
16095 
16096   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
16097 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
16098   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
16099   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
16100 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
16101 
16102   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
16103     OPENJDK=true
16104     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
16105       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
16106 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
16107     fi
16108   else
16109     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
16110       OPENJDK=true
16111     else
16112       OPENJDK=false
16113     fi
16114   fi
16115 
16116   if test "x$OPENJDK" = "xtrue"; then
16117     SET_OPENJDK="OPENJDK=true"
16118   fi
16119 
16120 
16121 
16122   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
16123   # the IncludeCustomExtension macro.
16124 
16125 
16126 # Check whether --with-custom-make-dir was given.
16127 if test "${with_custom_make_dir+set}" = set; then :
16128   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
16129 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
16130 fi
16131 
16132 
16133 
16134 
16135 # These are needed to be able to create a configuration name (and thus the output directory)
16136 
16137   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
16138 $as_echo_n "checking which variant of the JDK to build... " >&6; }
16139 
16140 # Check whether --with-jdk-variant was given.
16141 if test "${with_jdk_variant+set}" = set; then :
16142   withval=$with_jdk_variant;
16143 fi
16144 
16145 
16146   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
16147     JDK_VARIANT="normal"
16148   else
16149     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
16150   fi
16151 
16152 
16153 
16154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
16155 $as_echo "$JDK_VARIANT" >&6; }
16156 
16157 
16158   DEBUG_LEVEL="release"
16159   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
16160 $as_echo_n "checking which debug level to use... " >&6; }
16161   # Check whether --enable-debug was given.
16162 if test "${enable_debug+set}" = set; then :
16163   enableval=$enable_debug;
16164         ENABLE_DEBUG="${enableval}"
16165         DEBUG_LEVEL="fastdebug"
16166 
16167 else
16168   ENABLE_DEBUG="no"
16169 fi
16170 
16171 
16172 
16173 # Check whether --with-debug-level was given.
16174 if test "${with_debug_level+set}" = set; then :
16175   withval=$with_debug_level;
16176         DEBUG_LEVEL="${withval}"
16177         if test "x$ENABLE_DEBUG" = xyes; then
16178           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
16179         fi
16180 
16181 fi
16182 
16183   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
16184 $as_echo "$DEBUG_LEVEL" >&6; }
16185 
16186   if test "x$DEBUG_LEVEL" != xrelease && \
16187       test "x$DEBUG_LEVEL" != xoptimized && \
16188       test "x$DEBUG_LEVEL" != xfastdebug && \
16189       test "x$DEBUG_LEVEL" != xslowdebug; then
16190     as_fn_error $? "Allowed debug levels are: release, fastdebug, slowdebug and optimized" "$LINENO" 5
16191   fi
16192 
16193   # Translate DEBUG_LEVEL to debug level used by Hotspot
16194   HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
16195   if test "x$DEBUG_LEVEL" = xrelease; then
16196     HOTSPOT_DEBUG_LEVEL="product"
16197   elif test "x$DEBUG_LEVEL" = xslowdebug; then
16198     HOTSPOT_DEBUG_LEVEL="debug"
16199   fi
16200 
16201   if test "x$DEBUG_LEVEL" = xoptimized; then
16202     # The debug level 'optimized' is a little special because it is currently only
16203     # applicable to the HotSpot build where it means to build a completely
16204     # optimized version of the VM without any debugging code (like for the
16205     # 'release' debug level which is called 'product' in the HotSpot build) but
16206     # with the exception that it can contain additional code which is otherwise
16207     # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
16208     # test new and/or experimental features which are not intended for customer
16209     # shipment. Because these new features need to be tested and benchmarked in
16210     # real world scenarios, we want to build the containing JDK at the 'release'
16211     # debug level.
16212     DEBUG_LEVEL="release"
16213   fi
16214 
16215 
16216 
16217 
16218 
16219 
16220 # Check whether --with-jvm-variants was given.
16221 if test "${with_jvm_variants+set}" = set; then :
16222   withval=$with_jvm_variants;
16223 fi
16224 
16225 
16226   if test "x$with_jvm_variants" = x; then
16227     with_jvm_variants="server"
16228   fi
16229   JVM_VARIANTS_OPT="$with_jvm_variants"
16230 
16231   # Has the user listed more than one variant?
16232   # Additional [] needed to keep m4 from mangling shell constructs.
16233   if  [[ "$JVM_VARIANTS_OPT" =~ "," ]] ; then
16234     BUILDING_MULTIPLE_JVM_VARIANTS=true
16235   else
16236     BUILDING_MULTIPLE_JVM_VARIANTS=false
16237   fi
16238   # Replace the commas with AND for use in the build directory name.
16239   JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
16240 
16241   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
16242 $as_echo_n "checking which variants of the JVM to build... " >&6; }
16243   # JVM_VARIANTS is a space-separated list.
16244   # Also use minimal, not minimal1 (which is kept for backwards compatibility).
16245   JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
16246   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_VARIANTS" >&5
16247 $as_echo "$JVM_VARIANTS" >&6; }
16248 
16249   # Check that the selected variants are valid
16250 
16251   # grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
16252   # Notice that the original variant failes on SLES 10 and 11
16253   NEEDLE=${VALID_JVM_VARIANTS// /$'\n'}
16254   STACK=${JVM_VARIANTS// /$'\n'}
16255   INVALID_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16256   if test "x$INVALID_VARIANTS" != x; then
16257     { $as_echo "$as_me:${as_lineno-$LINENO}: Unknown variant(s) specified: $INVALID_VARIANTS" >&5
16258 $as_echo "$as_me: Unknown variant(s) specified: $INVALID_VARIANTS" >&6;}
16259     as_fn_error $? "The available JVM variants are: $VALID_JVM_VARIANTS" "$LINENO" 5
16260   fi
16261 
16262   # All "special" variants share the same output directory ("server")
16263   VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
16264   NEEDLE=${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}
16265   STACK=${JVM_VARIANTS// /$'\n'}
16266   INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
16267   if  test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
16268     as_fn_error $? "You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS." "$LINENO" 5
16269   fi
16270 
16271 
16272 
16273 
16274   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
16275     # zero behaves as a platform and rewrites these values. This is really weird. :(
16276     # We are guaranteed that we do not build any other variants when building zero.
16277     HOTSPOT_TARGET_CPU=zero
16278     HOTSPOT_TARGET_CPU_ARCH=zero
16279   fi
16280 
16281 
16282 # With basic setup done, call the custom early hook.
16283 
16284 
16285 # Check if we have devkits, extra paths or sysroot set.
16286 
16287 
16288 # Check whether --with-devkit was given.
16289 if test "${with_devkit+set}" = set; then :
16290   withval=$with_devkit;
16291 
16292   # Only process if variable expands to non-empty
16293 
16294   if test "x$with_devkit" != x; then
16295     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16296 
16297   # Input might be given as Windows format, start by converting to
16298   # unix format.
16299   path="$with_devkit"
16300   new_path=`$CYGPATH -u "$path"`
16301 
16302   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16303   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16304   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16305   # "foo.exe" is OK but "foo" is an error.
16306   #
16307   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16308   # It is also a way to make sure we got the proper file name for the real test later on.
16309   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16310   if test "x$test_shortpath" = x; then
16311     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16312 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16313     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
16314   fi
16315 
16316   # Call helper function which possibly converts this using DOS-style short mode.
16317   # If so, the updated path is stored in $new_path.
16318 
16319   input_path="$new_path"
16320   # Check if we need to convert this using DOS-style short mode. If the path
16321   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16322   # take no chances and rewrite it.
16323   # Note: m4 eats our [], so we need to use [ and ] instead.
16324   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16325   if test "x$has_forbidden_chars" != x; then
16326     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16327     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16328     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16329     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16330       # Going to short mode and back again did indeed matter. Since short mode is
16331       # case insensitive, let's make it lowercase to improve readability.
16332       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16333       # Now convert it back to Unix-style (cygpath)
16334       input_path=`$CYGPATH -u "$shortmode_path"`
16335       new_path="$input_path"
16336     fi
16337   fi
16338 
16339   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16340   if test "x$test_cygdrive_prefix" = x; then
16341     # As a simple fix, exclude /usr/bin since it's not a real path.
16342     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16343       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16344       # a path prefixed by /cygdrive for fixpath to work.
16345       new_path="$CYGWIN_ROOT_PATH$input_path"
16346     fi
16347   fi
16348 
16349 
16350   if test "x$path" != "x$new_path"; then
16351     with_devkit="$new_path"
16352     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16353 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16354   fi
16355 
16356     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16357 
16358   path="$with_devkit"
16359   has_colon=`$ECHO $path | $GREP ^.:`
16360   new_path="$path"
16361   if test "x$has_colon" = x; then
16362     # Not in mixed or Windows style, start by that.
16363     new_path=`cmd //c echo $path`
16364   fi
16365 
16366 
16367   input_path="$new_path"
16368   # Check if we need to convert this using DOS-style short mode. If the path
16369   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16370   # take no chances and rewrite it.
16371   # Note: m4 eats our [], so we need to use [ and ] instead.
16372   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16373   if test "x$has_forbidden_chars" != x; then
16374     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16375     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16376   fi
16377 
16378 
16379   windows_path="$new_path"
16380   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16381     unix_path=`$CYGPATH -u "$windows_path"`
16382     new_path="$unix_path"
16383   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16384     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16385     new_path="$unix_path"
16386   fi
16387 
16388   if test "x$path" != "x$new_path"; then
16389     with_devkit="$new_path"
16390     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
16391 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
16392   fi
16393 
16394   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16395   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16396 
16397     else
16398       # We're on a unix platform. Hooray! :)
16399       path="$with_devkit"
16400       has_space=`$ECHO "$path" | $GREP " "`
16401       if test "x$has_space" != x; then
16402         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
16403 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
16404         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16405       fi
16406 
16407       # Use eval to expand a potential ~
16408       eval path="$path"
16409       if test ! -f "$path" && test ! -d "$path"; then
16410         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
16411       fi
16412 
16413       if test -d "$path"; then
16414         with_devkit="`cd "$path"; $THEPWDCMD -L`"
16415       else
16416         dir="`$DIRNAME "$path"`"
16417         base="`$BASENAME "$path"`"
16418         with_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
16419       fi
16420     fi
16421   fi
16422 
16423         DEVKIT_ROOT="$with_devkit"
16424         # Check for a meta data info file in the root of the devkit
16425         if test -f "$DEVKIT_ROOT/devkit.info"; then
16426           . $DEVKIT_ROOT/devkit.info
16427           # This potentially sets the following:
16428           # A descriptive name of the devkit
16429 
16430   if test "x$DEVKIT_NAME" = x; then
16431     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
16432   fi
16433 
16434           # Corresponds to --with-extra-path
16435 
16436   if test "x$DEVKIT_EXTRA_PATH" = x; then
16437     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
16438   fi
16439 
16440           # Corresponds to --with-toolchain-path
16441 
16442   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16443     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
16444   fi
16445 
16446           # Corresponds to --with-sysroot
16447 
16448   if test "x$DEVKIT_SYSROOT" = x; then
16449     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
16450   fi
16451 
16452 
16453           # Identifies the Visual Studio version in the devkit
16454 
16455   if test "x$DEVKIT_VS_VERSION" = x; then
16456     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
16457   fi
16458 
16459           # The Visual Studio include environment variable
16460 
16461   if test "x$DEVKIT_VS_INCLUDE" = x; then
16462     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
16463   fi
16464 
16465           # The Visual Studio lib environment variable
16466 
16467   if test "x$DEVKIT_VS_LIB" = x; then
16468     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
16469   fi
16470 
16471           # Corresponds to --with-msvcr-dll
16472 
16473   if test "x$DEVKIT_MSVCR_DLL" = x; then
16474     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
16475   fi
16476 
16477           # Corresponds to --with-msvcp-dll
16478 
16479   if test "x$DEVKIT_MSVCP_DLL" = x; then
16480     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
16481   fi
16482 
16483         fi
16484 
16485         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
16486 $as_echo_n "checking for devkit... " >&6; }
16487         if test "x$DEVKIT_NAME" != x; then
16488           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
16489 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
16490         else
16491           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
16492 $as_echo "$DEVKIT_ROOT" >&6; }
16493         fi
16494 
16495 
16496   if test "x$DEVKIT_EXTRA_PATH" != x; then
16497     if test "x$EXTRA_PATH" = x; then
16498       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
16499     else
16500       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
16501     fi
16502   fi
16503 
16504 
16505         # Fallback default of just /bin if DEVKIT_PATH is not defined
16506         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
16507           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
16508         fi
16509 
16510   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
16511     if test "x$TOOLCHAIN_PATH" = x; then
16512       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
16513     else
16514       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
16515     fi
16516   fi
16517 
16518 
16519         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
16520         # places for backwards compatiblity.
16521         if test "x$DEVKIT_SYSROOT" != x; then
16522           SYSROOT="$DEVKIT_SYSROOT"
16523         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
16524           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
16525         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
16526           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
16527         fi
16528 
16529 
16530 fi
16531 
16532 
16533   # You can force the sysroot if the sysroot encoded into the compiler tools
16534   # is not correct.
16535 
16536 # Check whether --with-sys-root was given.
16537 if test "${with_sys_root+set}" = set; then :
16538   withval=$with_sys_root; SYSROOT=$with_sys_root
16539 
16540 fi
16541 
16542 
16543 
16544 # Check whether --with-sysroot was given.
16545 if test "${with_sysroot+set}" = set; then :
16546   withval=$with_sysroot; SYSROOT=$with_sysroot
16547 
16548 fi
16549 
16550 
16551 
16552 # Check whether --with-tools-dir was given.
16553 if test "${with_tools_dir+set}" = set; then :
16554   withval=$with_tools_dir;
16555   if test "x$with_tools_dir" != x; then
16556     if test "x$TOOLCHAIN_PATH" = x; then
16557       TOOLCHAIN_PATH="$with_tools_dir"
16558     else
16559       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
16560     fi
16561   fi
16562 
16563 
16564 fi
16565 
16566 
16567 
16568 # Check whether --with-toolchain-path was given.
16569 if test "${with_toolchain_path+set}" = set; then :
16570   withval=$with_toolchain_path;
16571   if test "x$with_toolchain_path" != x; then
16572     if test "x$TOOLCHAIN_PATH" = x; then
16573       TOOLCHAIN_PATH="$with_toolchain_path"
16574     else
16575       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
16576     fi
16577   fi
16578 
16579 
16580 fi
16581 
16582 
16583 
16584 # Check whether --with-extra-path was given.
16585 if test "${with_extra_path+set}" = set; then :
16586   withval=$with_extra_path;
16587   if test "x$with_extra_path" != x; then
16588     if test "x$EXTRA_PATH" = x; then
16589       EXTRA_PATH="$with_extra_path"
16590     else
16591       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
16592     fi
16593   fi
16594 
16595 
16596 fi
16597 
16598 
16599   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
16600     # If a devkit has been supplied, find xcodebuild in the toolchain_path.
16601     # If not, detect if Xcode is installed by running xcodebuild -version
16602     # if no Xcode installed, xcodebuild exits with 1
16603     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
16604     if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
16605       # We need to use xcodebuild in the toolchain dir provided by the user, this will
16606       # fall back on the stub binary in /usr/bin/xcodebuild
16607       # Extract the first word of "xcodebuild", so it can be a program name with args.
16608 set dummy xcodebuild; ac_word=$2
16609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16610 $as_echo_n "checking for $ac_word... " >&6; }
16611 if ${ac_cv_path_XCODEBUILD+:} false; then :
16612   $as_echo_n "(cached) " >&6
16613 else
16614   case $XCODEBUILD in
16615   [\\/]* | ?:[\\/]*)
16616   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
16617   ;;
16618   *)
16619   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16620 for as_dir in $TOOLCHAIN_PATH
16621 do
16622   IFS=$as_save_IFS
16623   test -z "$as_dir" && as_dir=.
16624     for ac_exec_ext in '' $ac_executable_extensions; do
16625   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16626     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
16627     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16628     break 2
16629   fi
16630 done
16631   done
16632 IFS=$as_save_IFS
16633 
16634   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
16635   ;;
16636 esac
16637 fi
16638 XCODEBUILD=$ac_cv_path_XCODEBUILD
16639 if test -n "$XCODEBUILD"; then
16640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
16641 $as_echo "$XCODEBUILD" >&6; }
16642 else
16643   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16644 $as_echo "no" >&6; }
16645 fi
16646 
16647 
16648     else
16649       # this should result in SYSROOT being empty, unless --with-sysroot is provided
16650       # when only the command line tools are installed there are no SDKs, so headers
16651       # are copied into the system frameworks
16652       XCODEBUILD=
16653 
16654     fi
16655 
16656     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
16657 $as_echo_n "checking for sdk name... " >&6; }
16658 
16659 # Check whether --with-sdk-name was given.
16660 if test "${with_sdk_name+set}" = set; then :
16661   withval=$with_sdk_name; SDKNAME=$with_sdk_name
16662 
16663 fi
16664 
16665     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
16666 $as_echo "$SDKNAME" >&6; }
16667 
16668     # if toolchain path is specified then don't rely on system headers, they may not compile
16669     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
16670     test -z "$TOOLCHAIN_PATH" && \
16671       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
16672 
16673     if test -z "$SYSROOT"; then
16674       if test -n "$XCODEBUILD"; then
16675         # if we don't have system headers, use default SDK name (last resort)
16676         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16677           SDKNAME=${SDKNAME:-macosx}
16678         fi
16679 
16680         if test -n "$SDKNAME"; then
16681           # Call xcodebuild to determine SYSROOT
16682           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
16683         fi
16684       else
16685         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
16686           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
16687         fi
16688       fi
16689     else
16690       # warn user if --with-sdk-name was also set
16691       if test -n "$with_sdk_name"; then
16692         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
16693 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
16694       fi
16695     fi
16696 
16697     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
16698       # If no system framework headers, then SYSROOT must be set, or we won't build
16699       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
16700     fi
16701 
16702     # Perform a basic sanity test
16703     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
16704       if test -z "$SYSROOT"; then
16705         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
16706       else
16707         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
16708       fi
16709     fi
16710 
16711     # set SDKROOT too, Xcode tools will pick it up
16712     SDKROOT=$SYSROOT
16713 
16714   fi
16715 
16716   # Prepend the extra path to the global path
16717 
16718   if test "x$EXTRA_PATH" != x; then
16719     if test "x$PATH" = x; then
16720       PATH="$EXTRA_PATH"
16721     else
16722       PATH="$EXTRA_PATH:$PATH"
16723     fi
16724   fi
16725 
16726 
16727   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
16728     # Add extra search paths on solaris for utilities like ar, as, dtrace etc...
16729     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:/usr/sbin"
16730   fi
16731 
16732   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
16733 $as_echo_n "checking for sysroot... " >&6; }
16734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
16735 $as_echo "$SYSROOT" >&6; }
16736   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
16737 $as_echo_n "checking for toolchain path... " >&6; }
16738   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
16739 $as_echo "$TOOLCHAIN_PATH" >&6; }
16740   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
16741 $as_echo_n "checking for extra path... " >&6; }
16742   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
16743 $as_echo "$EXTRA_PATH" >&6; }
16744 
16745 
16746 # To properly create a configuration name, we need to have the OpenJDK target
16747 # and options (variants and debug level) parsed.
16748 
16749 
16750 
16751 # Check whether --with-conf-name was given.
16752 if test "${with_conf_name+set}" = set; then :
16753   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
16754 fi
16755 
16756 
16757   # Test from where we are running configure, in or outside of src root.
16758   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
16759 $as_echo_n "checking where to store configuration... " >&6; }
16760   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
16761       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
16762       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
16763     # We are running configure from the src root.
16764     # Create a default ./build/target-variant-debuglevel output root.
16765     if test "x${CONF_NAME}" = x; then
16766       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
16767 $as_echo "in default location" >&6; }
16768       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
16769     else
16770       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
16771 $as_echo "in build directory with custom name" >&6; }
16772     fi
16773     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
16774     $MKDIR -p "$OUTPUT_ROOT"
16775     if test ! -d "$OUTPUT_ROOT"; then
16776       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
16777     fi
16778   else
16779     # We are running configure from outside of the src dir.
16780     # Then use the current directory as output dir!
16781     # If configuration is situated in normal build directory, just use the build
16782     # directory name as configuration name, otherwise use the complete path.
16783     if test "x${CONF_NAME}" = x; then
16784       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
16785     fi
16786     OUTPUT_ROOT="$CURDIR"
16787     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
16788 $as_echo "in current directory" >&6; }
16789 
16790     # WARNING: This might be a bad thing to do. You need to be sure you want to
16791     # have a configuration in this directory. Do some sanity checks!
16792 
16793     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
16794       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
16795       # other files
16796       files_present=`$LS $OUTPUT_ROOT`
16797       # Configure has already touched config.log and confdefs.h in the current dir when this check
16798       # is performed.
16799       filtered_files=`$ECHO "$files_present" \
16800           | $SED -e 's/config.log//g' \
16801               -e 's/configure.log//g' \
16802               -e 's/confdefs.h//g' \
16803               -e 's/ //g' \
16804           | $TR -d '\n'`
16805       if test "x$filtered_files" != x; then
16806         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
16807 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
16808         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
16809 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
16810         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
16811 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
16812         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
16813 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
16814         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
16815 $as_echo "$as_me: seriously mess up just about everything." >&6;}
16816         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
16817 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
16818         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
16819 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
16820         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
16821       fi
16822     fi
16823   fi
16824   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
16825 $as_echo_n "checking what configuration name to use... " >&6; }
16826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
16827 $as_echo "$CONF_NAME" >&6; }
16828 
16829 
16830   # Only process if variable expands to non-empty
16831 
16832   if test "x$OUTPUT_ROOT" != x; then
16833     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16834 
16835   # Input might be given as Windows format, start by converting to
16836   # unix format.
16837   path="$OUTPUT_ROOT"
16838   new_path=`$CYGPATH -u "$path"`
16839 
16840   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16841   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16842   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16843   # "foo.exe" is OK but "foo" is an error.
16844   #
16845   # This test is therefore slightly more accurate than "test -f" to check for file precense.
16846   # It is also a way to make sure we got the proper file name for the real test later on.
16847   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16848   if test "x$test_shortpath" = x; then
16849     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16850 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16851     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
16852   fi
16853 
16854   # Call helper function which possibly converts this using DOS-style short mode.
16855   # If so, the updated path is stored in $new_path.
16856 
16857   input_path="$new_path"
16858   # Check if we need to convert this using DOS-style short mode. If the path
16859   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16860   # take no chances and rewrite it.
16861   # Note: m4 eats our [], so we need to use [ and ] instead.
16862   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16863   if test "x$has_forbidden_chars" != x; then
16864     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16865     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16866     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16867     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16868       # Going to short mode and back again did indeed matter. Since short mode is
16869       # case insensitive, let's make it lowercase to improve readability.
16870       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16871       # Now convert it back to Unix-style (cygpath)
16872       input_path=`$CYGPATH -u "$shortmode_path"`
16873       new_path="$input_path"
16874     fi
16875   fi
16876 
16877   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16878   if test "x$test_cygdrive_prefix" = x; then
16879     # As a simple fix, exclude /usr/bin since it's not a real path.
16880     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
16881       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16882       # a path prefixed by /cygdrive for fixpath to work.
16883       new_path="$CYGWIN_ROOT_PATH$input_path"
16884     fi
16885   fi
16886 
16887 
16888   if test "x$path" != "x$new_path"; then
16889     OUTPUT_ROOT="$new_path"
16890     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16891 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16892   fi
16893 
16894     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16895 
16896   path="$OUTPUT_ROOT"
16897   has_colon=`$ECHO $path | $GREP ^.:`
16898   new_path="$path"
16899   if test "x$has_colon" = x; then
16900     # Not in mixed or Windows style, start by that.
16901     new_path=`cmd //c echo $path`
16902   fi
16903 
16904 
16905   input_path="$new_path"
16906   # Check if we need to convert this using DOS-style short mode. If the path
16907   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16908   # take no chances and rewrite it.
16909   # Note: m4 eats our [], so we need to use [ and ] instead.
16910   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16911   if test "x$has_forbidden_chars" != x; then
16912     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16913     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16914   fi
16915 
16916 
16917   windows_path="$new_path"
16918   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16919     unix_path=`$CYGPATH -u "$windows_path"`
16920     new_path="$unix_path"
16921   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16922     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16923     new_path="$unix_path"
16924   fi
16925 
16926   if test "x$path" != "x$new_path"; then
16927     OUTPUT_ROOT="$new_path"
16928     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
16929 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
16930   fi
16931 
16932   # Save the first 10 bytes of this path to the storage, so fixpath can work.
16933   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16934 
16935     else
16936       # We're on a unix platform. Hooray! :)
16937       path="$OUTPUT_ROOT"
16938       has_space=`$ECHO "$path" | $GREP " "`
16939       if test "x$has_space" != x; then
16940         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
16941 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
16942         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
16943       fi
16944 
16945       # Use eval to expand a potential ~
16946       eval path="$path"
16947       if test ! -f "$path" && test ! -d "$path"; then
16948         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
16949       fi
16950 
16951       if test -d "$path"; then
16952         OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
16953       else
16954         dir="`$DIRNAME "$path"`"
16955         base="`$BASENAME "$path"`"
16956         OUTPUT_ROOT="`cd "$dir"; $THEPWDCMD -L`/$base"
16957       fi
16958     fi
16959   fi
16960 
16961 
16962   CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
16963   $MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
16964 
16965   SPEC=$OUTPUT_ROOT/spec.gmk
16966 
16967   CONF_NAME=$CONF_NAME
16968 
16969   OUTPUT_ROOT=$OUTPUT_ROOT
16970 
16971 
16972 
16973   # The spec.gmk file contains all variables for the make system.
16974   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
16975 
16976   # The bootcycle-spec.gmk file contains support for boot cycle builds.
16977   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
16978 
16979   # The buildjdk-spec.gmk file contains support for building a buildjdk when cross compiling.
16980   ac_config_files="$ac_config_files $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in"
16981 
16982   # The compare.sh is used to compare the build output to other builds.
16983   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
16984 
16985   # The generated Makefile knows where the spec.gmk is and where the source is.
16986   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
16987   # which will look for generated configurations
16988   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
16989 
16990 
16991 
16992 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
16993 
16994   for ac_prog in apt-get yum port pkgutil pkgadd
16995 do
16996   # Extract the first word of "$ac_prog", so it can be a program name with args.
16997 set dummy $ac_prog; ac_word=$2
16998 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16999 $as_echo_n "checking for $ac_word... " >&6; }
17000 if ${ac_cv_prog_PKGHANDLER+:} false; then :
17001   $as_echo_n "(cached) " >&6
17002 else
17003   if test -n "$PKGHANDLER"; then
17004   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
17005 else
17006 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17007 for as_dir in $PATH
17008 do
17009   IFS=$as_save_IFS
17010   test -z "$as_dir" && as_dir=.
17011     for ac_exec_ext in '' $ac_executable_extensions; do
17012   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17013     ac_cv_prog_PKGHANDLER="$ac_prog"
17014     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17015     break 2
17016   fi
17017 done
17018   done
17019 IFS=$as_save_IFS
17020 
17021 fi
17022 fi
17023 PKGHANDLER=$ac_cv_prog_PKGHANDLER
17024 if test -n "$PKGHANDLER"; then
17025   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
17026 $as_echo "$PKGHANDLER" >&6; }
17027 else
17028   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17029 $as_echo "no" >&6; }
17030 fi
17031 
17032 
17033   test -n "$PKGHANDLER" && break
17034 done
17035 
17036 
17037 
17038 # Setup tools that requires more complex handling, or that is not needed by the configure script.
17039 
17040 
17041 
17042   # Publish this variable in the help.
17043 
17044 
17045   if [ -z "${MAKE+x}" ]; then
17046     # The variable is not set by user, try to locate tool using the code snippet
17047 
17048     # Try our hardest to locate a correct version of GNU make
17049     for ac_prog in gmake
17050 do
17051   # Extract the first word of "$ac_prog", so it can be a program name with args.
17052 set dummy $ac_prog; ac_word=$2
17053 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17054 $as_echo_n "checking for $ac_word... " >&6; }
17055 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
17056   $as_echo_n "(cached) " >&6
17057 else
17058   case $CHECK_GMAKE in
17059   [\\/]* | ?:[\\/]*)
17060   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
17061   ;;
17062   *)
17063   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17064 for as_dir in $PATH
17065 do
17066   IFS=$as_save_IFS
17067   test -z "$as_dir" && as_dir=.
17068     for ac_exec_ext in '' $ac_executable_extensions; do
17069   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17070     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17071     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17072     break 2
17073   fi
17074 done
17075   done
17076 IFS=$as_save_IFS
17077 
17078   ;;
17079 esac
17080 fi
17081 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
17082 if test -n "$CHECK_GMAKE"; then
17083   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
17084 $as_echo "$CHECK_GMAKE" >&6; }
17085 else
17086   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17087 $as_echo "no" >&6; }
17088 fi
17089 
17090 
17091   test -n "$CHECK_GMAKE" && break
17092 done
17093 
17094 
17095   MAKE_CANDIDATE=""$CHECK_GMAKE""
17096   DESCRIPTION="gmake in PATH"
17097 
17098   # On Cygwin, we require a newer version of make than on other platforms
17099   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17100     MAKE_VERSION_EXPR="-e 4\."
17101     MAKE_REQUIRED_VERSION="4.0"
17102    else
17103     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17104     MAKE_REQUIRED_VERSION="3.81"
17105   fi
17106 
17107   if test "x$MAKE_CANDIDATE" != x; then
17108     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17109 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17110     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17111     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17112     if test "x$IS_GNU_MAKE" = x; then
17113       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17114 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17115     else
17116       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17117       if test "x$IS_MODERN_MAKE" = x; then
17118         { $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
17119 $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;}
17120       else
17121         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17122           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17123             MAKE_EXPECTED_ENV='cygwin'
17124           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17125             MAKE_EXPECTED_ENV='msys'
17126           else
17127             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17128           fi
17129           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17130           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17131         else
17132           # Not relevant for non-Windows
17133           IS_MAKE_CORRECT_ENV=true
17134         fi
17135         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17136           { $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
17137 $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;}
17138         else
17139           FOUND_MAKE=$MAKE_CANDIDATE
17140 
17141   # Only process if variable expands to non-empty
17142 
17143   if test "x$FOUND_MAKE" != x; then
17144     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17145 
17146   # First separate the path from the arguments. This will split at the first
17147   # space.
17148   complete="$FOUND_MAKE"
17149   path="${complete%% *}"
17150   tmp="$complete EOL"
17151   arguments="${tmp#* }"
17152 
17153   # Input might be given as Windows format, start by converting to
17154   # unix format.
17155   new_path=`$CYGPATH -u "$path"`
17156 
17157   # Now try to locate executable using which
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     # Oops. Which didn't find the executable.
17168     # The splitting of arguments from the executable at a space might have been incorrect,
17169     # since paths with space are more likely in Windows. Give it another try with the whole
17170     # argument.
17171     path="$complete"
17172     arguments="EOL"
17173     new_path=`$CYGPATH -u "$path"`
17174     new_path=`$WHICH "$new_path" 2> /dev/null`
17175     # bat and cmd files are not always considered executable in cygwin causing which
17176     # to not find them
17177     if test "x$new_path" = x \
17178         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17179         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17180       new_path=`$CYGPATH -u "$path"`
17181     fi
17182     if test "x$new_path" = x; then
17183       # It's still not found. Now this is an unrecoverable error.
17184       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17185 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17186       has_space=`$ECHO "$complete" | $GREP " "`
17187       if test "x$has_space" != x; then
17188         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17189 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17190       fi
17191       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17192     fi
17193   fi
17194 
17195   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17196   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17197   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17198   # "foo.exe" is OK but "foo" is an error.
17199   #
17200   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17201   # It is also a way to make sure we got the proper file name for the real test later on.
17202   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17203   if test "x$test_shortpath" = x; then
17204     # Short path failed, file does not exist as specified.
17205     # Try adding .exe or .cmd
17206     if test -f "${new_path}.exe"; then
17207       input_to_shortpath="${new_path}.exe"
17208     elif test -f "${new_path}.cmd"; then
17209       input_to_shortpath="${new_path}.cmd"
17210     else
17211       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17212 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17213       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17214 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17215       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17216     fi
17217   else
17218     input_to_shortpath="$new_path"
17219   fi
17220 
17221   # Call helper function which possibly converts this using DOS-style short mode.
17222   # If so, the updated path is stored in $new_path.
17223   new_path="$input_to_shortpath"
17224 
17225   input_path="$input_to_shortpath"
17226   # Check if we need to convert this using DOS-style short mode. If the path
17227   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17228   # take no chances and rewrite it.
17229   # Note: m4 eats our [], so we need to use [ and ] instead.
17230   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17231   if test "x$has_forbidden_chars" != x; then
17232     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17233     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17234     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17235     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17236       # Going to short mode and back again did indeed matter. Since short mode is
17237       # case insensitive, let's make it lowercase to improve readability.
17238       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17239       # Now convert it back to Unix-style (cygpath)
17240       input_path=`$CYGPATH -u "$shortmode_path"`
17241       new_path="$input_path"
17242     fi
17243   fi
17244 
17245   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17246   if test "x$test_cygdrive_prefix" = x; then
17247     # As a simple fix, exclude /usr/bin since it's not a real path.
17248     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17249       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17250       # a path prefixed by /cygdrive for fixpath to work.
17251       new_path="$CYGWIN_ROOT_PATH$input_path"
17252     fi
17253   fi
17254 
17255   # remove trailing .exe if any
17256   new_path="${new_path/%.exe/}"
17257 
17258     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17259 
17260   # First separate the path from the arguments. This will split at the first
17261   # space.
17262   complete="$FOUND_MAKE"
17263   path="${complete%% *}"
17264   tmp="$complete EOL"
17265   arguments="${tmp#* }"
17266 
17267   # Input might be given as Windows format, start by converting to
17268   # unix format.
17269   new_path="$path"
17270 
17271   windows_path="$new_path"
17272   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17273     unix_path=`$CYGPATH -u "$windows_path"`
17274     new_path="$unix_path"
17275   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17276     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17277     new_path="$unix_path"
17278   fi
17279 
17280 
17281   # Now try to locate executable using which
17282   new_path=`$WHICH "$new_path" 2> /dev/null`
17283 
17284   if test "x$new_path" = x; then
17285     # Oops. Which didn't find the executable.
17286     # The splitting of arguments from the executable at a space might have been incorrect,
17287     # since paths with space are more likely in Windows. Give it another try with the whole
17288     # argument.
17289     path="$complete"
17290     arguments="EOL"
17291     new_path="$path"
17292 
17293   windows_path="$new_path"
17294   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17295     unix_path=`$CYGPATH -u "$windows_path"`
17296     new_path="$unix_path"
17297   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17298     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17299     new_path="$unix_path"
17300   fi
17301 
17302 
17303     new_path=`$WHICH "$new_path" 2> /dev/null`
17304     # bat and cmd files are not always considered executable in MSYS causing which
17305     # to not find them
17306     if test "x$new_path" = x \
17307         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17308         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17309       new_path="$path"
17310 
17311   windows_path="$new_path"
17312   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17313     unix_path=`$CYGPATH -u "$windows_path"`
17314     new_path="$unix_path"
17315   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17316     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17317     new_path="$unix_path"
17318   fi
17319 
17320     fi
17321 
17322     if test "x$new_path" = x; then
17323       # It's still not found. Now this is an unrecoverable error.
17324       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17325 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17326       has_space=`$ECHO "$complete" | $GREP " "`
17327       if test "x$has_space" != x; then
17328         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17329 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17330       fi
17331       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17332     fi
17333   fi
17334 
17335   # Now new_path has a complete unix path to the binary
17336   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17337     # Keep paths in /bin as-is, but remove trailing .exe if any
17338     new_path="${new_path/%.exe/}"
17339     # Do not save /bin paths to all_fixpath_prefixes!
17340   else
17341     # Not in mixed or Windows style, start by that.
17342     new_path=`cmd //c echo $new_path`
17343 
17344   input_path="$new_path"
17345   # Check if we need to convert this using DOS-style short mode. If the path
17346   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17347   # take no chances and rewrite it.
17348   # Note: m4 eats our [], so we need to use [ and ] instead.
17349   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17350   if test "x$has_forbidden_chars" != x; then
17351     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17352     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17353   fi
17354 
17355     # Output is in $new_path
17356 
17357   windows_path="$new_path"
17358   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17359     unix_path=`$CYGPATH -u "$windows_path"`
17360     new_path="$unix_path"
17361   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17362     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17363     new_path="$unix_path"
17364   fi
17365 
17366     # remove trailing .exe if any
17367     new_path="${new_path/%.exe/}"
17368 
17369     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17370     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17371   fi
17372 
17373     else
17374       # We're on a unix platform. Hooray! :)
17375       # First separate the path from the arguments. This will split at the first
17376       # space.
17377       complete="$FOUND_MAKE"
17378       path="${complete%% *}"
17379       tmp="$complete EOL"
17380       arguments="${tmp#* }"
17381 
17382       # Cannot rely on the command "which" here since it doesn't always work.
17383       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17384       if test -z "$is_absolute_path"; then
17385         # Path to executable is not absolute. Find it.
17386         IFS_save="$IFS"
17387         IFS=:
17388         for p in $PATH; do
17389           if test -f "$p/$path" && test -x "$p/$path"; then
17390             new_path="$p/$path"
17391             break
17392           fi
17393         done
17394         IFS="$IFS_save"
17395       else
17396         # This is an absolute path, we can use it without further modifications.
17397         new_path="$path"
17398       fi
17399 
17400       if test "x$new_path" = x; then
17401         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17402 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17403         has_space=`$ECHO "$complete" | $GREP " "`
17404         if test "x$has_space" != x; then
17405           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17406 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17407         fi
17408         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17409       fi
17410     fi
17411 
17412     # Now join together the path and the arguments once again
17413     if test "x$arguments" != xEOL; then
17414       new_complete="$new_path ${arguments% *}"
17415     else
17416       new_complete="$new_path"
17417     fi
17418 
17419     if test "x$complete" != "x$new_complete"; then
17420       FOUND_MAKE="$new_complete"
17421       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17422 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17423     fi
17424   fi
17425 
17426         fi
17427       fi
17428     fi
17429   fi
17430 
17431 
17432     if test "x$FOUND_MAKE" = x; then
17433       for ac_prog in make
17434 do
17435   # Extract the first word of "$ac_prog", so it can be a program name with args.
17436 set dummy $ac_prog; ac_word=$2
17437 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17438 $as_echo_n "checking for $ac_word... " >&6; }
17439 if ${ac_cv_path_CHECK_MAKE+:} false; then :
17440   $as_echo_n "(cached) " >&6
17441 else
17442   case $CHECK_MAKE in
17443   [\\/]* | ?:[\\/]*)
17444   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
17445   ;;
17446   *)
17447   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17448 for as_dir in $PATH
17449 do
17450   IFS=$as_save_IFS
17451   test -z "$as_dir" && as_dir=.
17452     for ac_exec_ext in '' $ac_executable_extensions; do
17453   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17454     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
17455     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17456     break 2
17457   fi
17458 done
17459   done
17460 IFS=$as_save_IFS
17461 
17462   ;;
17463 esac
17464 fi
17465 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
17466 if test -n "$CHECK_MAKE"; then
17467   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
17468 $as_echo "$CHECK_MAKE" >&6; }
17469 else
17470   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17471 $as_echo "no" >&6; }
17472 fi
17473 
17474 
17475   test -n "$CHECK_MAKE" && break
17476 done
17477 
17478 
17479   MAKE_CANDIDATE=""$CHECK_MAKE""
17480   DESCRIPTION="make in PATH"
17481 
17482   # On Cygwin, we require a newer version of make than on other platforms
17483   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17484     MAKE_VERSION_EXPR="-e 4\."
17485     MAKE_REQUIRED_VERSION="4.0"
17486    else
17487     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17488     MAKE_REQUIRED_VERSION="3.81"
17489   fi
17490 
17491   if test "x$MAKE_CANDIDATE" != x; then
17492     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17493 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17494     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17495     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17496     if test "x$IS_GNU_MAKE" = x; then
17497       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17498 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17499     else
17500       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17501       if test "x$IS_MODERN_MAKE" = x; then
17502         { $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
17503 $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;}
17504       else
17505         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17506           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17507             MAKE_EXPECTED_ENV='cygwin'
17508           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17509             MAKE_EXPECTED_ENV='msys'
17510           else
17511             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17512           fi
17513           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17514           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17515         else
17516           # Not relevant for non-Windows
17517           IS_MAKE_CORRECT_ENV=true
17518         fi
17519         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17520           { $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
17521 $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;}
17522         else
17523           FOUND_MAKE=$MAKE_CANDIDATE
17524 
17525   # Only process if variable expands to non-empty
17526 
17527   if test "x$FOUND_MAKE" != x; then
17528     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17529 
17530   # First separate the path from the arguments. This will split at the first
17531   # space.
17532   complete="$FOUND_MAKE"
17533   path="${complete%% *}"
17534   tmp="$complete EOL"
17535   arguments="${tmp#* }"
17536 
17537   # Input might be given as Windows format, start by converting to
17538   # unix format.
17539   new_path=`$CYGPATH -u "$path"`
17540 
17541   # Now try to locate executable using which
17542   new_path=`$WHICH "$new_path" 2> /dev/null`
17543   # bat and cmd files are not always considered executable in cygwin causing which
17544   # to not find them
17545   if test "x$new_path" = x \
17546       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17547       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17548     new_path=`$CYGPATH -u "$path"`
17549   fi
17550   if test "x$new_path" = x; then
17551     # Oops. Which didn't find the executable.
17552     # The splitting of arguments from the executable at a space might have been incorrect,
17553     # since paths with space are more likely in Windows. Give it another try with the whole
17554     # argument.
17555     path="$complete"
17556     arguments="EOL"
17557     new_path=`$CYGPATH -u "$path"`
17558     new_path=`$WHICH "$new_path" 2> /dev/null`
17559     # bat and cmd files are not always considered executable in cygwin causing which
17560     # to not find them
17561     if test "x$new_path" = x \
17562         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17563         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17564       new_path=`$CYGPATH -u "$path"`
17565     fi
17566     if test "x$new_path" = x; then
17567       # It's still not found. Now this is an unrecoverable error.
17568       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17569 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17570       has_space=`$ECHO "$complete" | $GREP " "`
17571       if test "x$has_space" != x; then
17572         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17573 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17574       fi
17575       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17576     fi
17577   fi
17578 
17579   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17580   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17581   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17582   # "foo.exe" is OK but "foo" is an error.
17583   #
17584   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17585   # It is also a way to make sure we got the proper file name for the real test later on.
17586   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17587   if test "x$test_shortpath" = x; then
17588     # Short path failed, file does not exist as specified.
17589     # Try adding .exe or .cmd
17590     if test -f "${new_path}.exe"; then
17591       input_to_shortpath="${new_path}.exe"
17592     elif test -f "${new_path}.cmd"; then
17593       input_to_shortpath="${new_path}.cmd"
17594     else
17595       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17596 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17597       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17598 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17599       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17600     fi
17601   else
17602     input_to_shortpath="$new_path"
17603   fi
17604 
17605   # Call helper function which possibly converts this using DOS-style short mode.
17606   # If so, the updated path is stored in $new_path.
17607   new_path="$input_to_shortpath"
17608 
17609   input_path="$input_to_shortpath"
17610   # Check if we need to convert this using DOS-style short mode. If the path
17611   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17612   # take no chances and rewrite it.
17613   # Note: m4 eats our [], so we need to use [ and ] instead.
17614   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17615   if test "x$has_forbidden_chars" != x; then
17616     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17617     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17618     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17619     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17620       # Going to short mode and back again did indeed matter. Since short mode is
17621       # case insensitive, let's make it lowercase to improve readability.
17622       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17623       # Now convert it back to Unix-style (cygpath)
17624       input_path=`$CYGPATH -u "$shortmode_path"`
17625       new_path="$input_path"
17626     fi
17627   fi
17628 
17629   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17630   if test "x$test_cygdrive_prefix" = x; then
17631     # As a simple fix, exclude /usr/bin since it's not a real path.
17632     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17633       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17634       # a path prefixed by /cygdrive for fixpath to work.
17635       new_path="$CYGWIN_ROOT_PATH$input_path"
17636     fi
17637   fi
17638 
17639   # remove trailing .exe if any
17640   new_path="${new_path/%.exe/}"
17641 
17642     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17643 
17644   # First separate the path from the arguments. This will split at the first
17645   # space.
17646   complete="$FOUND_MAKE"
17647   path="${complete%% *}"
17648   tmp="$complete EOL"
17649   arguments="${tmp#* }"
17650 
17651   # Input might be given as Windows format, start by converting to
17652   # unix format.
17653   new_path="$path"
17654 
17655   windows_path="$new_path"
17656   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17657     unix_path=`$CYGPATH -u "$windows_path"`
17658     new_path="$unix_path"
17659   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17660     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17661     new_path="$unix_path"
17662   fi
17663 
17664 
17665   # Now try to locate executable using which
17666   new_path=`$WHICH "$new_path" 2> /dev/null`
17667 
17668   if test "x$new_path" = x; then
17669     # Oops. Which didn't find the executable.
17670     # The splitting of arguments from the executable at a space might have been incorrect,
17671     # since paths with space are more likely in Windows. Give it another try with the whole
17672     # argument.
17673     path="$complete"
17674     arguments="EOL"
17675     new_path="$path"
17676 
17677   windows_path="$new_path"
17678   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17679     unix_path=`$CYGPATH -u "$windows_path"`
17680     new_path="$unix_path"
17681   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17682     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17683     new_path="$unix_path"
17684   fi
17685 
17686 
17687     new_path=`$WHICH "$new_path" 2> /dev/null`
17688     # bat and cmd files are not always considered executable in MSYS causing which
17689     # to not find them
17690     if test "x$new_path" = x \
17691         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17692         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17693       new_path="$path"
17694 
17695   windows_path="$new_path"
17696   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17697     unix_path=`$CYGPATH -u "$windows_path"`
17698     new_path="$unix_path"
17699   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17700     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17701     new_path="$unix_path"
17702   fi
17703 
17704     fi
17705 
17706     if test "x$new_path" = x; then
17707       # It's still not found. Now this is an unrecoverable error.
17708       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17709 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17710       has_space=`$ECHO "$complete" | $GREP " "`
17711       if test "x$has_space" != x; then
17712         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17713 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17714       fi
17715       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17716     fi
17717   fi
17718 
17719   # Now new_path has a complete unix path to the binary
17720   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17721     # Keep paths in /bin as-is, but remove trailing .exe if any
17722     new_path="${new_path/%.exe/}"
17723     # Do not save /bin paths to all_fixpath_prefixes!
17724   else
17725     # Not in mixed or Windows style, start by that.
17726     new_path=`cmd //c echo $new_path`
17727 
17728   input_path="$new_path"
17729   # Check if we need to convert this using DOS-style short mode. If the path
17730   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17731   # take no chances and rewrite it.
17732   # Note: m4 eats our [], so we need to use [ and ] instead.
17733   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17734   if test "x$has_forbidden_chars" != x; then
17735     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17736     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17737   fi
17738 
17739     # Output is in $new_path
17740 
17741   windows_path="$new_path"
17742   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17743     unix_path=`$CYGPATH -u "$windows_path"`
17744     new_path="$unix_path"
17745   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17746     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17747     new_path="$unix_path"
17748   fi
17749 
17750     # remove trailing .exe if any
17751     new_path="${new_path/%.exe/}"
17752 
17753     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17754     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17755   fi
17756 
17757     else
17758       # We're on a unix platform. Hooray! :)
17759       # First separate the path from the arguments. This will split at the first
17760       # space.
17761       complete="$FOUND_MAKE"
17762       path="${complete%% *}"
17763       tmp="$complete EOL"
17764       arguments="${tmp#* }"
17765 
17766       # Cannot rely on the command "which" here since it doesn't always work.
17767       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17768       if test -z "$is_absolute_path"; then
17769         # Path to executable is not absolute. Find it.
17770         IFS_save="$IFS"
17771         IFS=:
17772         for p in $PATH; do
17773           if test -f "$p/$path" && test -x "$p/$path"; then
17774             new_path="$p/$path"
17775             break
17776           fi
17777         done
17778         IFS="$IFS_save"
17779       else
17780         # This is an absolute path, we can use it without further modifications.
17781         new_path="$path"
17782       fi
17783 
17784       if test "x$new_path" = x; then
17785         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17786 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17787         has_space=`$ECHO "$complete" | $GREP " "`
17788         if test "x$has_space" != x; then
17789           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17790 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17791         fi
17792         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17793       fi
17794     fi
17795 
17796     # Now join together the path and the arguments once again
17797     if test "x$arguments" != xEOL; then
17798       new_complete="$new_path ${arguments% *}"
17799     else
17800       new_complete="$new_path"
17801     fi
17802 
17803     if test "x$complete" != "x$new_complete"; then
17804       FOUND_MAKE="$new_complete"
17805       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17806 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17807     fi
17808   fi
17809 
17810         fi
17811       fi
17812     fi
17813   fi
17814 
17815     fi
17816 
17817     if test "x$FOUND_MAKE" = x; then
17818       if test "x$TOOLCHAIN_PATH" != x; then
17819         # We have a toolchain path, check that as well before giving up.
17820         OLD_PATH=$PATH
17821         PATH=$TOOLCHAIN_PATH:$PATH
17822         for ac_prog in gmake
17823 do
17824   # Extract the first word of "$ac_prog", so it can be a program name with args.
17825 set dummy $ac_prog; ac_word=$2
17826 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17827 $as_echo_n "checking for $ac_word... " >&6; }
17828 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
17829   $as_echo_n "(cached) " >&6
17830 else
17831   case $CHECK_TOOLSDIR_GMAKE in
17832   [\\/]* | ?:[\\/]*)
17833   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
17834   ;;
17835   *)
17836   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17837 for as_dir in $PATH
17838 do
17839   IFS=$as_save_IFS
17840   test -z "$as_dir" && as_dir=.
17841     for ac_exec_ext in '' $ac_executable_extensions; do
17842   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17843     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
17844     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17845     break 2
17846   fi
17847 done
17848   done
17849 IFS=$as_save_IFS
17850 
17851   ;;
17852 esac
17853 fi
17854 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
17855 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
17856   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
17857 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
17858 else
17859   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17860 $as_echo "no" >&6; }
17861 fi
17862 
17863 
17864   test -n "$CHECK_TOOLSDIR_GMAKE" && break
17865 done
17866 
17867 
17868   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
17869   DESCRIPTION="gmake in tools-dir"
17870 
17871   # On Cygwin, we require a newer version of make than on other platforms
17872   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17873     MAKE_VERSION_EXPR="-e 4\."
17874     MAKE_REQUIRED_VERSION="4.0"
17875    else
17876     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
17877     MAKE_REQUIRED_VERSION="3.81"
17878   fi
17879 
17880   if test "x$MAKE_CANDIDATE" != x; then
17881     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
17882 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
17883     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
17884     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
17885     if test "x$IS_GNU_MAKE" = x; then
17886       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
17887 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
17888     else
17889       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
17890       if test "x$IS_MODERN_MAKE" = x; then
17891         { $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
17892 $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;}
17893       else
17894         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
17895           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17896             MAKE_EXPECTED_ENV='cygwin'
17897           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17898             MAKE_EXPECTED_ENV='msys'
17899           else
17900             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
17901           fi
17902           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
17903           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
17904         else
17905           # Not relevant for non-Windows
17906           IS_MAKE_CORRECT_ENV=true
17907         fi
17908         if test "x$IS_MAKE_CORRECT_ENV" = x; then
17909           { $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
17910 $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;}
17911         else
17912           FOUND_MAKE=$MAKE_CANDIDATE
17913 
17914   # Only process if variable expands to non-empty
17915 
17916   if test "x$FOUND_MAKE" != x; then
17917     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17918 
17919   # First separate the path from the arguments. This will split at the first
17920   # space.
17921   complete="$FOUND_MAKE"
17922   path="${complete%% *}"
17923   tmp="$complete EOL"
17924   arguments="${tmp#* }"
17925 
17926   # Input might be given as Windows format, start by converting to
17927   # unix format.
17928   new_path=`$CYGPATH -u "$path"`
17929 
17930   # Now try to locate executable using which
17931   new_path=`$WHICH "$new_path" 2> /dev/null`
17932   # bat and cmd files are not always considered executable in cygwin causing which
17933   # to not find them
17934   if test "x$new_path" = x \
17935       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17936       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17937     new_path=`$CYGPATH -u "$path"`
17938   fi
17939   if test "x$new_path" = x; then
17940     # Oops. Which didn't find the executable.
17941     # The splitting of arguments from the executable at a space might have been incorrect,
17942     # since paths with space are more likely in Windows. Give it another try with the whole
17943     # argument.
17944     path="$complete"
17945     arguments="EOL"
17946     new_path=`$CYGPATH -u "$path"`
17947     new_path=`$WHICH "$new_path" 2> /dev/null`
17948     # bat and cmd files are not always considered executable in cygwin causing which
17949     # to not find them
17950     if test "x$new_path" = x \
17951         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17952         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17953       new_path=`$CYGPATH -u "$path"`
17954     fi
17955     if test "x$new_path" = x; then
17956       # It's still not found. Now this is an unrecoverable error.
17957       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17958 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17959       has_space=`$ECHO "$complete" | $GREP " "`
17960       if test "x$has_space" != x; then
17961         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17962 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17963       fi
17964       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17965     fi
17966   fi
17967 
17968   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17969   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17970   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17971   # "foo.exe" is OK but "foo" is an error.
17972   #
17973   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17974   # It is also a way to make sure we got the proper file name for the real test later on.
17975   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17976   if test "x$test_shortpath" = x; then
17977     # Short path failed, file does not exist as specified.
17978     # Try adding .exe or .cmd
17979     if test -f "${new_path}.exe"; then
17980       input_to_shortpath="${new_path}.exe"
17981     elif test -f "${new_path}.cmd"; then
17982       input_to_shortpath="${new_path}.cmd"
17983     else
17984       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17985 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17986       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17987 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17988       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17989     fi
17990   else
17991     input_to_shortpath="$new_path"
17992   fi
17993 
17994   # Call helper function which possibly converts this using DOS-style short mode.
17995   # If so, the updated path is stored in $new_path.
17996   new_path="$input_to_shortpath"
17997 
17998   input_path="$input_to_shortpath"
17999   # Check if we need to convert this using DOS-style short mode. If the path
18000   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18001   # take no chances and rewrite it.
18002   # Note: m4 eats our [], so we need to use [ and ] instead.
18003   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18004   if test "x$has_forbidden_chars" != x; then
18005     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18006     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18007     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18008     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18009       # Going to short mode and back again did indeed matter. Since short mode is
18010       # case insensitive, let's make it lowercase to improve readability.
18011       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18012       # Now convert it back to Unix-style (cygpath)
18013       input_path=`$CYGPATH -u "$shortmode_path"`
18014       new_path="$input_path"
18015     fi
18016   fi
18017 
18018   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18019   if test "x$test_cygdrive_prefix" = x; then
18020     # As a simple fix, exclude /usr/bin since it's not a real path.
18021     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18022       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18023       # a path prefixed by /cygdrive for fixpath to work.
18024       new_path="$CYGWIN_ROOT_PATH$input_path"
18025     fi
18026   fi
18027 
18028   # remove trailing .exe if any
18029   new_path="${new_path/%.exe/}"
18030 
18031     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18032 
18033   # First separate the path from the arguments. This will split at the first
18034   # space.
18035   complete="$FOUND_MAKE"
18036   path="${complete%% *}"
18037   tmp="$complete EOL"
18038   arguments="${tmp#* }"
18039 
18040   # Input might be given as Windows format, start by converting to
18041   # unix format.
18042   new_path="$path"
18043 
18044   windows_path="$new_path"
18045   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18046     unix_path=`$CYGPATH -u "$windows_path"`
18047     new_path="$unix_path"
18048   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18049     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18050     new_path="$unix_path"
18051   fi
18052 
18053 
18054   # Now try to locate executable using which
18055   new_path=`$WHICH "$new_path" 2> /dev/null`
18056 
18057   if test "x$new_path" = x; then
18058     # Oops. Which didn't find the executable.
18059     # The splitting of arguments from the executable at a space might have been incorrect,
18060     # since paths with space are more likely in Windows. Give it another try with the whole
18061     # argument.
18062     path="$complete"
18063     arguments="EOL"
18064     new_path="$path"
18065 
18066   windows_path="$new_path"
18067   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18068     unix_path=`$CYGPATH -u "$windows_path"`
18069     new_path="$unix_path"
18070   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18071     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18072     new_path="$unix_path"
18073   fi
18074 
18075 
18076     new_path=`$WHICH "$new_path" 2> /dev/null`
18077     # bat and cmd files are not always considered executable in MSYS causing which
18078     # to not find them
18079     if test "x$new_path" = x \
18080         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18081         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18082       new_path="$path"
18083 
18084   windows_path="$new_path"
18085   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18086     unix_path=`$CYGPATH -u "$windows_path"`
18087     new_path="$unix_path"
18088   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18089     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18090     new_path="$unix_path"
18091   fi
18092 
18093     fi
18094 
18095     if test "x$new_path" = x; then
18096       # It's still not found. Now this is an unrecoverable error.
18097       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18098 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18099       has_space=`$ECHO "$complete" | $GREP " "`
18100       if test "x$has_space" != x; then
18101         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18102 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18103       fi
18104       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18105     fi
18106   fi
18107 
18108   # Now new_path has a complete unix path to the binary
18109   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18110     # Keep paths in /bin as-is, but remove trailing .exe if any
18111     new_path="${new_path/%.exe/}"
18112     # Do not save /bin paths to all_fixpath_prefixes!
18113   else
18114     # Not in mixed or Windows style, start by that.
18115     new_path=`cmd //c echo $new_path`
18116 
18117   input_path="$new_path"
18118   # Check if we need to convert this using DOS-style short mode. If the path
18119   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18120   # take no chances and rewrite it.
18121   # Note: m4 eats our [], so we need to use [ and ] instead.
18122   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18123   if test "x$has_forbidden_chars" != x; then
18124     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18125     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18126   fi
18127 
18128     # Output is in $new_path
18129 
18130   windows_path="$new_path"
18131   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18132     unix_path=`$CYGPATH -u "$windows_path"`
18133     new_path="$unix_path"
18134   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18135     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18136     new_path="$unix_path"
18137   fi
18138 
18139     # remove trailing .exe if any
18140     new_path="${new_path/%.exe/}"
18141 
18142     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18143     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18144   fi
18145 
18146     else
18147       # We're on a unix platform. Hooray! :)
18148       # First separate the path from the arguments. This will split at the first
18149       # space.
18150       complete="$FOUND_MAKE"
18151       path="${complete%% *}"
18152       tmp="$complete EOL"
18153       arguments="${tmp#* }"
18154 
18155       # Cannot rely on the command "which" here since it doesn't always work.
18156       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18157       if test -z "$is_absolute_path"; then
18158         # Path to executable is not absolute. Find it.
18159         IFS_save="$IFS"
18160         IFS=:
18161         for p in $PATH; do
18162           if test -f "$p/$path" && test -x "$p/$path"; then
18163             new_path="$p/$path"
18164             break
18165           fi
18166         done
18167         IFS="$IFS_save"
18168       else
18169         # This is an absolute path, we can use it without further modifications.
18170         new_path="$path"
18171       fi
18172 
18173       if test "x$new_path" = x; then
18174         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18175 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18176         has_space=`$ECHO "$complete" | $GREP " "`
18177         if test "x$has_space" != x; then
18178           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18179 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18180         fi
18181         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18182       fi
18183     fi
18184 
18185     # Now join together the path and the arguments once again
18186     if test "x$arguments" != xEOL; then
18187       new_complete="$new_path ${arguments% *}"
18188     else
18189       new_complete="$new_path"
18190     fi
18191 
18192     if test "x$complete" != "x$new_complete"; then
18193       FOUND_MAKE="$new_complete"
18194       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18195 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18196     fi
18197   fi
18198 
18199         fi
18200       fi
18201     fi
18202   fi
18203 
18204         if test "x$FOUND_MAKE" = x; then
18205           for ac_prog in make
18206 do
18207   # Extract the first word of "$ac_prog", so it can be a program name with args.
18208 set dummy $ac_prog; ac_word=$2
18209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18210 $as_echo_n "checking for $ac_word... " >&6; }
18211 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
18212   $as_echo_n "(cached) " >&6
18213 else
18214   case $CHECK_TOOLSDIR_MAKE in
18215   [\\/]* | ?:[\\/]*)
18216   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
18217   ;;
18218   *)
18219   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18220 for as_dir in $PATH
18221 do
18222   IFS=$as_save_IFS
18223   test -z "$as_dir" && as_dir=.
18224     for ac_exec_ext in '' $ac_executable_extensions; do
18225   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18226     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
18227     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18228     break 2
18229   fi
18230 done
18231   done
18232 IFS=$as_save_IFS
18233 
18234   ;;
18235 esac
18236 fi
18237 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
18238 if test -n "$CHECK_TOOLSDIR_MAKE"; then
18239   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
18240 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
18241 else
18242   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18243 $as_echo "no" >&6; }
18244 fi
18245 
18246 
18247   test -n "$CHECK_TOOLSDIR_MAKE" && break
18248 done
18249 
18250 
18251   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
18252   DESCRIPTION="make in tools-dir"
18253 
18254   # On Cygwin, we require a newer version of make than on other platforms
18255   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18256     MAKE_VERSION_EXPR="-e 4\."
18257     MAKE_REQUIRED_VERSION="4.0"
18258    else
18259     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18260     MAKE_REQUIRED_VERSION="3.81"
18261   fi
18262 
18263   if test "x$MAKE_CANDIDATE" != x; then
18264     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18265 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18266     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18267     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18268     if test "x$IS_GNU_MAKE" = x; then
18269       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18270 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18271     else
18272       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18273       if test "x$IS_MODERN_MAKE" = x; then
18274         { $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
18275 $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;}
18276       else
18277         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18278           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18279             MAKE_EXPECTED_ENV='cygwin'
18280           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18281             MAKE_EXPECTED_ENV='msys'
18282           else
18283             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18284           fi
18285           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18286           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18287         else
18288           # Not relevant for non-Windows
18289           IS_MAKE_CORRECT_ENV=true
18290         fi
18291         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18292           { $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
18293 $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;}
18294         else
18295           FOUND_MAKE=$MAKE_CANDIDATE
18296 
18297   # Only process if variable expands to non-empty
18298 
18299   if test "x$FOUND_MAKE" != x; then
18300     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18301 
18302   # First separate the path from the arguments. This will split at the first
18303   # space.
18304   complete="$FOUND_MAKE"
18305   path="${complete%% *}"
18306   tmp="$complete EOL"
18307   arguments="${tmp#* }"
18308 
18309   # Input might be given as Windows format, start by converting to
18310   # unix format.
18311   new_path=`$CYGPATH -u "$path"`
18312 
18313   # Now try to locate executable using which
18314   new_path=`$WHICH "$new_path" 2> /dev/null`
18315   # bat and cmd files are not always considered executable in cygwin causing which
18316   # to not find them
18317   if test "x$new_path" = x \
18318       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18319       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18320     new_path=`$CYGPATH -u "$path"`
18321   fi
18322   if test "x$new_path" = x; then
18323     # Oops. Which didn't find the executable.
18324     # The splitting of arguments from the executable at a space might have been incorrect,
18325     # since paths with space are more likely in Windows. Give it another try with the whole
18326     # argument.
18327     path="$complete"
18328     arguments="EOL"
18329     new_path=`$CYGPATH -u "$path"`
18330     new_path=`$WHICH "$new_path" 2> /dev/null`
18331     # bat and cmd files are not always considered executable in cygwin causing which
18332     # to not find them
18333     if test "x$new_path" = x \
18334         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18335         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18336       new_path=`$CYGPATH -u "$path"`
18337     fi
18338     if test "x$new_path" = x; then
18339       # It's still not found. Now this is an unrecoverable error.
18340       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18341 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18342       has_space=`$ECHO "$complete" | $GREP " "`
18343       if test "x$has_space" != x; then
18344         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18345 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18346       fi
18347       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18348     fi
18349   fi
18350 
18351   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18352   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18353   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18354   # "foo.exe" is OK but "foo" is an error.
18355   #
18356   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18357   # It is also a way to make sure we got the proper file name for the real test later on.
18358   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18359   if test "x$test_shortpath" = x; then
18360     # Short path failed, file does not exist as specified.
18361     # Try adding .exe or .cmd
18362     if test -f "${new_path}.exe"; then
18363       input_to_shortpath="${new_path}.exe"
18364     elif test -f "${new_path}.cmd"; then
18365       input_to_shortpath="${new_path}.cmd"
18366     else
18367       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18368 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18369       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18370 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18371       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18372     fi
18373   else
18374     input_to_shortpath="$new_path"
18375   fi
18376 
18377   # Call helper function which possibly converts this using DOS-style short mode.
18378   # If so, the updated path is stored in $new_path.
18379   new_path="$input_to_shortpath"
18380 
18381   input_path="$input_to_shortpath"
18382   # Check if we need to convert this using DOS-style short mode. If the path
18383   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18384   # take no chances and rewrite it.
18385   # Note: m4 eats our [], so we need to use [ and ] instead.
18386   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18387   if test "x$has_forbidden_chars" != x; then
18388     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18389     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18390     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18391     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18392       # Going to short mode and back again did indeed matter. Since short mode is
18393       # case insensitive, let's make it lowercase to improve readability.
18394       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18395       # Now convert it back to Unix-style (cygpath)
18396       input_path=`$CYGPATH -u "$shortmode_path"`
18397       new_path="$input_path"
18398     fi
18399   fi
18400 
18401   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18402   if test "x$test_cygdrive_prefix" = x; then
18403     # As a simple fix, exclude /usr/bin since it's not a real path.
18404     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18405       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18406       # a path prefixed by /cygdrive for fixpath to work.
18407       new_path="$CYGWIN_ROOT_PATH$input_path"
18408     fi
18409   fi
18410 
18411   # remove trailing .exe if any
18412   new_path="${new_path/%.exe/}"
18413 
18414     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18415 
18416   # First separate the path from the arguments. This will split at the first
18417   # space.
18418   complete="$FOUND_MAKE"
18419   path="${complete%% *}"
18420   tmp="$complete EOL"
18421   arguments="${tmp#* }"
18422 
18423   # Input might be given as Windows format, start by converting to
18424   # unix format.
18425   new_path="$path"
18426 
18427   windows_path="$new_path"
18428   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18429     unix_path=`$CYGPATH -u "$windows_path"`
18430     new_path="$unix_path"
18431   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18432     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18433     new_path="$unix_path"
18434   fi
18435 
18436 
18437   # Now try to locate executable using which
18438   new_path=`$WHICH "$new_path" 2> /dev/null`
18439 
18440   if test "x$new_path" = x; then
18441     # Oops. Which didn't find the executable.
18442     # The splitting of arguments from the executable at a space might have been incorrect,
18443     # since paths with space are more likely in Windows. Give it another try with the whole
18444     # argument.
18445     path="$complete"
18446     arguments="EOL"
18447     new_path="$path"
18448 
18449   windows_path="$new_path"
18450   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18451     unix_path=`$CYGPATH -u "$windows_path"`
18452     new_path="$unix_path"
18453   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18454     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18455     new_path="$unix_path"
18456   fi
18457 
18458 
18459     new_path=`$WHICH "$new_path" 2> /dev/null`
18460     # bat and cmd files are not always considered executable in MSYS causing which
18461     # to not find them
18462     if test "x$new_path" = x \
18463         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18464         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18465       new_path="$path"
18466 
18467   windows_path="$new_path"
18468   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18469     unix_path=`$CYGPATH -u "$windows_path"`
18470     new_path="$unix_path"
18471   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18472     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18473     new_path="$unix_path"
18474   fi
18475 
18476     fi
18477 
18478     if test "x$new_path" = x; then
18479       # It's still not found. Now this is an unrecoverable error.
18480       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18481 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18482       has_space=`$ECHO "$complete" | $GREP " "`
18483       if test "x$has_space" != x; then
18484         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18485 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18486       fi
18487       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18488     fi
18489   fi
18490 
18491   # Now new_path has a complete unix path to the binary
18492   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18493     # Keep paths in /bin as-is, but remove trailing .exe if any
18494     new_path="${new_path/%.exe/}"
18495     # Do not save /bin paths to all_fixpath_prefixes!
18496   else
18497     # Not in mixed or Windows style, start by that.
18498     new_path=`cmd //c echo $new_path`
18499 
18500   input_path="$new_path"
18501   # Check if we need to convert this using DOS-style short mode. If the path
18502   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18503   # take no chances and rewrite it.
18504   # Note: m4 eats our [], so we need to use [ and ] instead.
18505   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18506   if test "x$has_forbidden_chars" != x; then
18507     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18508     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18509   fi
18510 
18511     # Output is in $new_path
18512 
18513   windows_path="$new_path"
18514   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18515     unix_path=`$CYGPATH -u "$windows_path"`
18516     new_path="$unix_path"
18517   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18518     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18519     new_path="$unix_path"
18520   fi
18521 
18522     # remove trailing .exe if any
18523     new_path="${new_path/%.exe/}"
18524 
18525     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18526     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18527   fi
18528 
18529     else
18530       # We're on a unix platform. Hooray! :)
18531       # First separate the path from the arguments. This will split at the first
18532       # space.
18533       complete="$FOUND_MAKE"
18534       path="${complete%% *}"
18535       tmp="$complete EOL"
18536       arguments="${tmp#* }"
18537 
18538       # Cannot rely on the command "which" here since it doesn't always work.
18539       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18540       if test -z "$is_absolute_path"; then
18541         # Path to executable is not absolute. Find it.
18542         IFS_save="$IFS"
18543         IFS=:
18544         for p in $PATH; do
18545           if test -f "$p/$path" && test -x "$p/$path"; then
18546             new_path="$p/$path"
18547             break
18548           fi
18549         done
18550         IFS="$IFS_save"
18551       else
18552         # This is an absolute path, we can use it without further modifications.
18553         new_path="$path"
18554       fi
18555 
18556       if test "x$new_path" = x; then
18557         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18558 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18559         has_space=`$ECHO "$complete" | $GREP " "`
18560         if test "x$has_space" != x; then
18561           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18562 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18563         fi
18564         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18565       fi
18566     fi
18567 
18568     # Now join together the path and the arguments once again
18569     if test "x$arguments" != xEOL; then
18570       new_complete="$new_path ${arguments% *}"
18571     else
18572       new_complete="$new_path"
18573     fi
18574 
18575     if test "x$complete" != "x$new_complete"; then
18576       FOUND_MAKE="$new_complete"
18577       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18578 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18579     fi
18580   fi
18581 
18582         fi
18583       fi
18584     fi
18585   fi
18586 
18587         fi
18588         PATH=$OLD_PATH
18589       fi
18590     fi
18591 
18592     if test "x$FOUND_MAKE" = x; then
18593       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
18594     fi
18595 
18596   else
18597     # The variable is set, but is it from the command line or the environment?
18598 
18599     # Try to remove the string !MAKE! from our list.
18600     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
18601     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18602       # If it failed, the variable was not from the command line. Ignore it,
18603       # but warn the user (except for BASH, which is always set by the calling BASH).
18604       if test "xMAKE" != xBASH; then
18605         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
18606 $as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
18607       fi
18608       # Try to locate tool using the code snippet
18609 
18610     # Try our hardest to locate a correct version of GNU make
18611     for ac_prog in gmake
18612 do
18613   # Extract the first word of "$ac_prog", so it can be a program name with args.
18614 set dummy $ac_prog; ac_word=$2
18615 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18616 $as_echo_n "checking for $ac_word... " >&6; }
18617 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
18618   $as_echo_n "(cached) " >&6
18619 else
18620   case $CHECK_GMAKE in
18621   [\\/]* | ?:[\\/]*)
18622   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
18623   ;;
18624   *)
18625   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18626 for as_dir in $PATH
18627 do
18628   IFS=$as_save_IFS
18629   test -z "$as_dir" && as_dir=.
18630     for ac_exec_ext in '' $ac_executable_extensions; do
18631   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18632     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
18633     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18634     break 2
18635   fi
18636 done
18637   done
18638 IFS=$as_save_IFS
18639 
18640   ;;
18641 esac
18642 fi
18643 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
18644 if test -n "$CHECK_GMAKE"; then
18645   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
18646 $as_echo "$CHECK_GMAKE" >&6; }
18647 else
18648   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18649 $as_echo "no" >&6; }
18650 fi
18651 
18652 
18653   test -n "$CHECK_GMAKE" && break
18654 done
18655 
18656 
18657   MAKE_CANDIDATE=""$CHECK_GMAKE""
18658   DESCRIPTION="gmake in PATH"
18659 
18660   # On Cygwin, we require a newer version of make than on other platforms
18661   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18662     MAKE_VERSION_EXPR="-e 4\."
18663     MAKE_REQUIRED_VERSION="4.0"
18664    else
18665     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
18666     MAKE_REQUIRED_VERSION="3.81"
18667   fi
18668 
18669   if test "x$MAKE_CANDIDATE" != x; then
18670     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
18671 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
18672     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
18673     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
18674     if test "x$IS_GNU_MAKE" = x; then
18675       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
18676 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
18677     else
18678       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
18679       if test "x$IS_MODERN_MAKE" = x; then
18680         { $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
18681 $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;}
18682       else
18683         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
18684           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18685             MAKE_EXPECTED_ENV='cygwin'
18686           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18687             MAKE_EXPECTED_ENV='msys'
18688           else
18689             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
18690           fi
18691           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
18692           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
18693         else
18694           # Not relevant for non-Windows
18695           IS_MAKE_CORRECT_ENV=true
18696         fi
18697         if test "x$IS_MAKE_CORRECT_ENV" = x; then
18698           { $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
18699 $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;}
18700         else
18701           FOUND_MAKE=$MAKE_CANDIDATE
18702 
18703   # Only process if variable expands to non-empty
18704 
18705   if test "x$FOUND_MAKE" != x; then
18706     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18707 
18708   # First separate the path from the arguments. This will split at the first
18709   # space.
18710   complete="$FOUND_MAKE"
18711   path="${complete%% *}"
18712   tmp="$complete EOL"
18713   arguments="${tmp#* }"
18714 
18715   # Input might be given as Windows format, start by converting to
18716   # unix format.
18717   new_path=`$CYGPATH -u "$path"`
18718 
18719   # Now try to locate executable using which
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     # Oops. Which didn't find the executable.
18730     # The splitting of arguments from the executable at a space might have been incorrect,
18731     # since paths with space are more likely in Windows. Give it another try with the whole
18732     # argument.
18733     path="$complete"
18734     arguments="EOL"
18735     new_path=`$CYGPATH -u "$path"`
18736     new_path=`$WHICH "$new_path" 2> /dev/null`
18737     # bat and cmd files are not always considered executable in cygwin causing which
18738     # to not find them
18739     if test "x$new_path" = x \
18740         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18741         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18742       new_path=`$CYGPATH -u "$path"`
18743     fi
18744     if test "x$new_path" = x; then
18745       # It's still not found. Now this is an unrecoverable error.
18746       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18747 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18748       has_space=`$ECHO "$complete" | $GREP " "`
18749       if test "x$has_space" != x; then
18750         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18751 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18752       fi
18753       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18754     fi
18755   fi
18756 
18757   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
18758   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
18759   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
18760   # "foo.exe" is OK but "foo" is an error.
18761   #
18762   # This test is therefore slightly more accurate than "test -f" to check for file presence.
18763   # It is also a way to make sure we got the proper file name for the real test later on.
18764   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
18765   if test "x$test_shortpath" = x; then
18766     # Short path failed, file does not exist as specified.
18767     # Try adding .exe or .cmd
18768     if test -f "${new_path}.exe"; then
18769       input_to_shortpath="${new_path}.exe"
18770     elif test -f "${new_path}.cmd"; then
18771       input_to_shortpath="${new_path}.cmd"
18772     else
18773       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
18774 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
18775       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
18776 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
18777       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18778     fi
18779   else
18780     input_to_shortpath="$new_path"
18781   fi
18782 
18783   # Call helper function which possibly converts this using DOS-style short mode.
18784   # If so, the updated path is stored in $new_path.
18785   new_path="$input_to_shortpath"
18786 
18787   input_path="$input_to_shortpath"
18788   # Check if we need to convert this using DOS-style short mode. If the path
18789   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18790   # take no chances and rewrite it.
18791   # Note: m4 eats our [], so we need to use [ and ] instead.
18792   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
18793   if test "x$has_forbidden_chars" != x; then
18794     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18795     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
18796     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
18797     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
18798       # Going to short mode and back again did indeed matter. Since short mode is
18799       # case insensitive, let's make it lowercase to improve readability.
18800       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18801       # Now convert it back to Unix-style (cygpath)
18802       input_path=`$CYGPATH -u "$shortmode_path"`
18803       new_path="$input_path"
18804     fi
18805   fi
18806 
18807   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
18808   if test "x$test_cygdrive_prefix" = x; then
18809     # As a simple fix, exclude /usr/bin since it's not a real path.
18810     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
18811       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
18812       # a path prefixed by /cygdrive for fixpath to work.
18813       new_path="$CYGWIN_ROOT_PATH$input_path"
18814     fi
18815   fi
18816 
18817   # remove trailing .exe if any
18818   new_path="${new_path/%.exe/}"
18819 
18820     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18821 
18822   # First separate the path from the arguments. This will split at the first
18823   # space.
18824   complete="$FOUND_MAKE"
18825   path="${complete%% *}"
18826   tmp="$complete EOL"
18827   arguments="${tmp#* }"
18828 
18829   # Input might be given as Windows format, start by converting to
18830   # unix format.
18831   new_path="$path"
18832 
18833   windows_path="$new_path"
18834   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18835     unix_path=`$CYGPATH -u "$windows_path"`
18836     new_path="$unix_path"
18837   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18838     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18839     new_path="$unix_path"
18840   fi
18841 
18842 
18843   # Now try to locate executable using which
18844   new_path=`$WHICH "$new_path" 2> /dev/null`
18845 
18846   if test "x$new_path" = x; then
18847     # Oops. Which didn't find the executable.
18848     # The splitting of arguments from the executable at a space might have been incorrect,
18849     # since paths with space are more likely in Windows. Give it another try with the whole
18850     # argument.
18851     path="$complete"
18852     arguments="EOL"
18853     new_path="$path"
18854 
18855   windows_path="$new_path"
18856   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18857     unix_path=`$CYGPATH -u "$windows_path"`
18858     new_path="$unix_path"
18859   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18860     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18861     new_path="$unix_path"
18862   fi
18863 
18864 
18865     new_path=`$WHICH "$new_path" 2> /dev/null`
18866     # bat and cmd files are not always considered executable in MSYS causing which
18867     # to not find them
18868     if test "x$new_path" = x \
18869         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
18870         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
18871       new_path="$path"
18872 
18873   windows_path="$new_path"
18874   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18875     unix_path=`$CYGPATH -u "$windows_path"`
18876     new_path="$unix_path"
18877   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18878     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18879     new_path="$unix_path"
18880   fi
18881 
18882     fi
18883 
18884     if test "x$new_path" = x; then
18885       # It's still not found. Now this is an unrecoverable error.
18886       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18887 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18888       has_space=`$ECHO "$complete" | $GREP " "`
18889       if test "x$has_space" != x; then
18890         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
18891 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
18892       fi
18893       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18894     fi
18895   fi
18896 
18897   # Now new_path has a complete unix path to the binary
18898   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
18899     # Keep paths in /bin as-is, but remove trailing .exe if any
18900     new_path="${new_path/%.exe/}"
18901     # Do not save /bin paths to all_fixpath_prefixes!
18902   else
18903     # Not in mixed or Windows style, start by that.
18904     new_path=`cmd //c echo $new_path`
18905 
18906   input_path="$new_path"
18907   # Check if we need to convert this using DOS-style short mode. If the path
18908   # contains just simple characters, use it. Otherwise (spaces, weird characters),
18909   # take no chances and rewrite it.
18910   # Note: m4 eats our [], so we need to use [ and ] instead.
18911   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
18912   if test "x$has_forbidden_chars" != x; then
18913     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
18914     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
18915   fi
18916 
18917     # Output is in $new_path
18918 
18919   windows_path="$new_path"
18920   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
18921     unix_path=`$CYGPATH -u "$windows_path"`
18922     new_path="$unix_path"
18923   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
18924     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
18925     new_path="$unix_path"
18926   fi
18927 
18928     # remove trailing .exe if any
18929     new_path="${new_path/%.exe/}"
18930 
18931     # Save the first 10 bytes of this path to the storage, so fixpath can work.
18932     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
18933   fi
18934 
18935     else
18936       # We're on a unix platform. Hooray! :)
18937       # First separate the path from the arguments. This will split at the first
18938       # space.
18939       complete="$FOUND_MAKE"
18940       path="${complete%% *}"
18941       tmp="$complete EOL"
18942       arguments="${tmp#* }"
18943 
18944       # Cannot rely on the command "which" here since it doesn't always work.
18945       is_absolute_path=`$ECHO "$path" | $GREP ^/`
18946       if test -z "$is_absolute_path"; then
18947         # Path to executable is not absolute. Find it.
18948         IFS_save="$IFS"
18949         IFS=:
18950         for p in $PATH; do
18951           if test -f "$p/$path" && test -x "$p/$path"; then
18952             new_path="$p/$path"
18953             break
18954           fi
18955         done
18956         IFS="$IFS_save"
18957       else
18958         # This is an absolute path, we can use it without further modifications.
18959         new_path="$path"
18960       fi
18961 
18962       if test "x$new_path" = x; then
18963         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
18964 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
18965         has_space=`$ECHO "$complete" | $GREP " "`
18966         if test "x$has_space" != x; then
18967           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
18968 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
18969         fi
18970         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
18971       fi
18972     fi
18973 
18974     # Now join together the path and the arguments once again
18975     if test "x$arguments" != xEOL; then
18976       new_complete="$new_path ${arguments% *}"
18977     else
18978       new_complete="$new_path"
18979     fi
18980 
18981     if test "x$complete" != "x$new_complete"; then
18982       FOUND_MAKE="$new_complete"
18983       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
18984 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
18985     fi
18986   fi
18987 
18988         fi
18989       fi
18990     fi
18991   fi
18992 
18993 
18994     if test "x$FOUND_MAKE" = x; then
18995       for ac_prog in make
18996 do
18997   # Extract the first word of "$ac_prog", so it can be a program name with args.
18998 set dummy $ac_prog; ac_word=$2
18999 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19000 $as_echo_n "checking for $ac_word... " >&6; }
19001 if ${ac_cv_path_CHECK_MAKE+:} false; then :
19002   $as_echo_n "(cached) " >&6
19003 else
19004   case $CHECK_MAKE in
19005   [\\/]* | ?:[\\/]*)
19006   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
19007   ;;
19008   *)
19009   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19010 for as_dir in $PATH
19011 do
19012   IFS=$as_save_IFS
19013   test -z "$as_dir" && as_dir=.
19014     for ac_exec_ext in '' $ac_executable_extensions; do
19015   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19016     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
19017     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19018     break 2
19019   fi
19020 done
19021   done
19022 IFS=$as_save_IFS
19023 
19024   ;;
19025 esac
19026 fi
19027 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
19028 if test -n "$CHECK_MAKE"; then
19029   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
19030 $as_echo "$CHECK_MAKE" >&6; }
19031 else
19032   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19033 $as_echo "no" >&6; }
19034 fi
19035 
19036 
19037   test -n "$CHECK_MAKE" && break
19038 done
19039 
19040 
19041   MAKE_CANDIDATE=""$CHECK_MAKE""
19042   DESCRIPTION="make in PATH"
19043 
19044   # On Cygwin, we require a newer version of make than on other platforms
19045   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19046     MAKE_VERSION_EXPR="-e 4\."
19047     MAKE_REQUIRED_VERSION="4.0"
19048    else
19049     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19050     MAKE_REQUIRED_VERSION="3.81"
19051   fi
19052 
19053   if test "x$MAKE_CANDIDATE" != x; then
19054     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19055 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19056     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19057     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19058     if test "x$IS_GNU_MAKE" = x; then
19059       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19060 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19061     else
19062       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19063       if test "x$IS_MODERN_MAKE" = x; then
19064         { $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
19065 $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;}
19066       else
19067         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19068           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19069             MAKE_EXPECTED_ENV='cygwin'
19070           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19071             MAKE_EXPECTED_ENV='msys'
19072           else
19073             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19074           fi
19075           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19076           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19077         else
19078           # Not relevant for non-Windows
19079           IS_MAKE_CORRECT_ENV=true
19080         fi
19081         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19082           { $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
19083 $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;}
19084         else
19085           FOUND_MAKE=$MAKE_CANDIDATE
19086 
19087   # Only process if variable expands to non-empty
19088 
19089   if test "x$FOUND_MAKE" != x; then
19090     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19091 
19092   # First separate the path from the arguments. This will split at the first
19093   # space.
19094   complete="$FOUND_MAKE"
19095   path="${complete%% *}"
19096   tmp="$complete EOL"
19097   arguments="${tmp#* }"
19098 
19099   # Input might be given as Windows format, start by converting to
19100   # unix format.
19101   new_path=`$CYGPATH -u "$path"`
19102 
19103   # Now try to locate executable using which
19104   new_path=`$WHICH "$new_path" 2> /dev/null`
19105   # bat and cmd files are not always considered executable in cygwin causing which
19106   # to not find them
19107   if test "x$new_path" = x \
19108       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19109       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19110     new_path=`$CYGPATH -u "$path"`
19111   fi
19112   if test "x$new_path" = x; then
19113     # Oops. Which didn't find the executable.
19114     # The splitting of arguments from the executable at a space might have been incorrect,
19115     # since paths with space are more likely in Windows. Give it another try with the whole
19116     # argument.
19117     path="$complete"
19118     arguments="EOL"
19119     new_path=`$CYGPATH -u "$path"`
19120     new_path=`$WHICH "$new_path" 2> /dev/null`
19121     # bat and cmd files are not always considered executable in cygwin causing which
19122     # to not find them
19123     if test "x$new_path" = x \
19124         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19125         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19126       new_path=`$CYGPATH -u "$path"`
19127     fi
19128     if test "x$new_path" = x; then
19129       # It's still not found. Now this is an unrecoverable error.
19130       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19131 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19132       has_space=`$ECHO "$complete" | $GREP " "`
19133       if test "x$has_space" != x; then
19134         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19135 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19136       fi
19137       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19138     fi
19139   fi
19140 
19141   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19142   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19143   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19144   # "foo.exe" is OK but "foo" is an error.
19145   #
19146   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19147   # It is also a way to make sure we got the proper file name for the real test later on.
19148   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19149   if test "x$test_shortpath" = x; then
19150     # Short path failed, file does not exist as specified.
19151     # Try adding .exe or .cmd
19152     if test -f "${new_path}.exe"; then
19153       input_to_shortpath="${new_path}.exe"
19154     elif test -f "${new_path}.cmd"; then
19155       input_to_shortpath="${new_path}.cmd"
19156     else
19157       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19158 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19159       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19160 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19161       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19162     fi
19163   else
19164     input_to_shortpath="$new_path"
19165   fi
19166 
19167   # Call helper function which possibly converts this using DOS-style short mode.
19168   # If so, the updated path is stored in $new_path.
19169   new_path="$input_to_shortpath"
19170 
19171   input_path="$input_to_shortpath"
19172   # Check if we need to convert this using DOS-style short mode. If the path
19173   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19174   # take no chances and rewrite it.
19175   # Note: m4 eats our [], so we need to use [ and ] instead.
19176   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19177   if test "x$has_forbidden_chars" != x; then
19178     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19179     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19180     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19181     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19182       # Going to short mode and back again did indeed matter. Since short mode is
19183       # case insensitive, let's make it lowercase to improve readability.
19184       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19185       # Now convert it back to Unix-style (cygpath)
19186       input_path=`$CYGPATH -u "$shortmode_path"`
19187       new_path="$input_path"
19188     fi
19189   fi
19190 
19191   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19192   if test "x$test_cygdrive_prefix" = x; then
19193     # As a simple fix, exclude /usr/bin since it's not a real path.
19194     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19195       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19196       # a path prefixed by /cygdrive for fixpath to work.
19197       new_path="$CYGWIN_ROOT_PATH$input_path"
19198     fi
19199   fi
19200 
19201   # remove trailing .exe if any
19202   new_path="${new_path/%.exe/}"
19203 
19204     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19205 
19206   # First separate the path from the arguments. This will split at the first
19207   # space.
19208   complete="$FOUND_MAKE"
19209   path="${complete%% *}"
19210   tmp="$complete EOL"
19211   arguments="${tmp#* }"
19212 
19213   # Input might be given as Windows format, start by converting to
19214   # unix format.
19215   new_path="$path"
19216 
19217   windows_path="$new_path"
19218   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19219     unix_path=`$CYGPATH -u "$windows_path"`
19220     new_path="$unix_path"
19221   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19222     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19223     new_path="$unix_path"
19224   fi
19225 
19226 
19227   # Now try to locate executable using which
19228   new_path=`$WHICH "$new_path" 2> /dev/null`
19229 
19230   if test "x$new_path" = x; then
19231     # Oops. Which didn't find the executable.
19232     # The splitting of arguments from the executable at a space might have been incorrect,
19233     # since paths with space are more likely in Windows. Give it another try with the whole
19234     # argument.
19235     path="$complete"
19236     arguments="EOL"
19237     new_path="$path"
19238 
19239   windows_path="$new_path"
19240   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19241     unix_path=`$CYGPATH -u "$windows_path"`
19242     new_path="$unix_path"
19243   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19244     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19245     new_path="$unix_path"
19246   fi
19247 
19248 
19249     new_path=`$WHICH "$new_path" 2> /dev/null`
19250     # bat and cmd files are not always considered executable in MSYS causing which
19251     # to not find them
19252     if test "x$new_path" = x \
19253         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19254         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19255       new_path="$path"
19256 
19257   windows_path="$new_path"
19258   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19259     unix_path=`$CYGPATH -u "$windows_path"`
19260     new_path="$unix_path"
19261   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19262     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19263     new_path="$unix_path"
19264   fi
19265 
19266     fi
19267 
19268     if test "x$new_path" = x; then
19269       # It's still not found. Now this is an unrecoverable error.
19270       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19271 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19272       has_space=`$ECHO "$complete" | $GREP " "`
19273       if test "x$has_space" != x; then
19274         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19275 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19276       fi
19277       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19278     fi
19279   fi
19280 
19281   # Now new_path has a complete unix path to the binary
19282   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19283     # Keep paths in /bin as-is, but remove trailing .exe if any
19284     new_path="${new_path/%.exe/}"
19285     # Do not save /bin paths to all_fixpath_prefixes!
19286   else
19287     # Not in mixed or Windows style, start by that.
19288     new_path=`cmd //c echo $new_path`
19289 
19290   input_path="$new_path"
19291   # Check if we need to convert this using DOS-style short mode. If the path
19292   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19293   # take no chances and rewrite it.
19294   # Note: m4 eats our [], so we need to use [ and ] instead.
19295   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19296   if test "x$has_forbidden_chars" != x; then
19297     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19298     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19299   fi
19300 
19301     # Output is in $new_path
19302 
19303   windows_path="$new_path"
19304   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19305     unix_path=`$CYGPATH -u "$windows_path"`
19306     new_path="$unix_path"
19307   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19308     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19309     new_path="$unix_path"
19310   fi
19311 
19312     # remove trailing .exe if any
19313     new_path="${new_path/%.exe/}"
19314 
19315     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19316     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19317   fi
19318 
19319     else
19320       # We're on a unix platform. Hooray! :)
19321       # First separate the path from the arguments. This will split at the first
19322       # space.
19323       complete="$FOUND_MAKE"
19324       path="${complete%% *}"
19325       tmp="$complete EOL"
19326       arguments="${tmp#* }"
19327 
19328       # Cannot rely on the command "which" here since it doesn't always work.
19329       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19330       if test -z "$is_absolute_path"; then
19331         # Path to executable is not absolute. Find it.
19332         IFS_save="$IFS"
19333         IFS=:
19334         for p in $PATH; do
19335           if test -f "$p/$path" && test -x "$p/$path"; then
19336             new_path="$p/$path"
19337             break
19338           fi
19339         done
19340         IFS="$IFS_save"
19341       else
19342         # This is an absolute path, we can use it without further modifications.
19343         new_path="$path"
19344       fi
19345 
19346       if test "x$new_path" = x; then
19347         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19348 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19349         has_space=`$ECHO "$complete" | $GREP " "`
19350         if test "x$has_space" != x; then
19351           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19352 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19353         fi
19354         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19355       fi
19356     fi
19357 
19358     # Now join together the path and the arguments once again
19359     if test "x$arguments" != xEOL; then
19360       new_complete="$new_path ${arguments% *}"
19361     else
19362       new_complete="$new_path"
19363     fi
19364 
19365     if test "x$complete" != "x$new_complete"; then
19366       FOUND_MAKE="$new_complete"
19367       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19368 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19369     fi
19370   fi
19371 
19372         fi
19373       fi
19374     fi
19375   fi
19376 
19377     fi
19378 
19379     if test "x$FOUND_MAKE" = x; then
19380       if test "x$TOOLCHAIN_PATH" != x; then
19381         # We have a toolchain path, check that as well before giving up.
19382         OLD_PATH=$PATH
19383         PATH=$TOOLCHAIN_PATH:$PATH
19384         for ac_prog in gmake
19385 do
19386   # Extract the first word of "$ac_prog", so it can be a program name with args.
19387 set dummy $ac_prog; ac_word=$2
19388 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19389 $as_echo_n "checking for $ac_word... " >&6; }
19390 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
19391   $as_echo_n "(cached) " >&6
19392 else
19393   case $CHECK_TOOLSDIR_GMAKE in
19394   [\\/]* | ?:[\\/]*)
19395   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
19396   ;;
19397   *)
19398   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19399 for as_dir in $PATH
19400 do
19401   IFS=$as_save_IFS
19402   test -z "$as_dir" && as_dir=.
19403     for ac_exec_ext in '' $ac_executable_extensions; do
19404   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19405     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
19406     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19407     break 2
19408   fi
19409 done
19410   done
19411 IFS=$as_save_IFS
19412 
19413   ;;
19414 esac
19415 fi
19416 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
19417 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
19418   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
19419 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
19420 else
19421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19422 $as_echo "no" >&6; }
19423 fi
19424 
19425 
19426   test -n "$CHECK_TOOLSDIR_GMAKE" && break
19427 done
19428 
19429 
19430   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
19431   DESCRIPTION="gmake in tools-dir"
19432 
19433   # On Cygwin, we require a newer version of make than on other platforms
19434   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19435     MAKE_VERSION_EXPR="-e 4\."
19436     MAKE_REQUIRED_VERSION="4.0"
19437    else
19438     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19439     MAKE_REQUIRED_VERSION="3.81"
19440   fi
19441 
19442   if test "x$MAKE_CANDIDATE" != x; then
19443     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19444 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19445     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19446     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19447     if test "x$IS_GNU_MAKE" = x; then
19448       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19449 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19450     else
19451       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19452       if test "x$IS_MODERN_MAKE" = x; then
19453         { $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
19454 $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;}
19455       else
19456         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19457           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19458             MAKE_EXPECTED_ENV='cygwin'
19459           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19460             MAKE_EXPECTED_ENV='msys'
19461           else
19462             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19463           fi
19464           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19465           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19466         else
19467           # Not relevant for non-Windows
19468           IS_MAKE_CORRECT_ENV=true
19469         fi
19470         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19471           { $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
19472 $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;}
19473         else
19474           FOUND_MAKE=$MAKE_CANDIDATE
19475 
19476   # Only process if variable expands to non-empty
19477 
19478   if test "x$FOUND_MAKE" != x; then
19479     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19480 
19481   # First separate the path from the arguments. This will split at the first
19482   # space.
19483   complete="$FOUND_MAKE"
19484   path="${complete%% *}"
19485   tmp="$complete EOL"
19486   arguments="${tmp#* }"
19487 
19488   # Input might be given as Windows format, start by converting to
19489   # unix format.
19490   new_path=`$CYGPATH -u "$path"`
19491 
19492   # Now try to locate executable using which
19493   new_path=`$WHICH "$new_path" 2> /dev/null`
19494   # bat and cmd files are not always considered executable in cygwin causing which
19495   # to not find them
19496   if test "x$new_path" = x \
19497       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19498       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19499     new_path=`$CYGPATH -u "$path"`
19500   fi
19501   if test "x$new_path" = x; then
19502     # Oops. Which didn't find the executable.
19503     # The splitting of arguments from the executable at a space might have been incorrect,
19504     # since paths with space are more likely in Windows. Give it another try with the whole
19505     # argument.
19506     path="$complete"
19507     arguments="EOL"
19508     new_path=`$CYGPATH -u "$path"`
19509     new_path=`$WHICH "$new_path" 2> /dev/null`
19510     # bat and cmd files are not always considered executable in cygwin causing which
19511     # to not find them
19512     if test "x$new_path" = x \
19513         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19514         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19515       new_path=`$CYGPATH -u "$path"`
19516     fi
19517     if test "x$new_path" = x; then
19518       # It's still not found. Now this is an unrecoverable error.
19519       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19520 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19521       has_space=`$ECHO "$complete" | $GREP " "`
19522       if test "x$has_space" != x; then
19523         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19524 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19525       fi
19526       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19527     fi
19528   fi
19529 
19530   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19531   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19532   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19533   # "foo.exe" is OK but "foo" is an error.
19534   #
19535   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19536   # It is also a way to make sure we got the proper file name for the real test later on.
19537   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19538   if test "x$test_shortpath" = x; then
19539     # Short path failed, file does not exist as specified.
19540     # Try adding .exe or .cmd
19541     if test -f "${new_path}.exe"; then
19542       input_to_shortpath="${new_path}.exe"
19543     elif test -f "${new_path}.cmd"; then
19544       input_to_shortpath="${new_path}.cmd"
19545     else
19546       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19547 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19548       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19549 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19550       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19551     fi
19552   else
19553     input_to_shortpath="$new_path"
19554   fi
19555 
19556   # Call helper function which possibly converts this using DOS-style short mode.
19557   # If so, the updated path is stored in $new_path.
19558   new_path="$input_to_shortpath"
19559 
19560   input_path="$input_to_shortpath"
19561   # Check if we need to convert this using DOS-style short mode. If the path
19562   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19563   # take no chances and rewrite it.
19564   # Note: m4 eats our [], so we need to use [ and ] instead.
19565   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19566   if test "x$has_forbidden_chars" != x; then
19567     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19568     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19569     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19570     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19571       # Going to short mode and back again did indeed matter. Since short mode is
19572       # case insensitive, let's make it lowercase to improve readability.
19573       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19574       # Now convert it back to Unix-style (cygpath)
19575       input_path=`$CYGPATH -u "$shortmode_path"`
19576       new_path="$input_path"
19577     fi
19578   fi
19579 
19580   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19581   if test "x$test_cygdrive_prefix" = x; then
19582     # As a simple fix, exclude /usr/bin since it's not a real path.
19583     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19584       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19585       # a path prefixed by /cygdrive for fixpath to work.
19586       new_path="$CYGWIN_ROOT_PATH$input_path"
19587     fi
19588   fi
19589 
19590   # remove trailing .exe if any
19591   new_path="${new_path/%.exe/}"
19592 
19593     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19594 
19595   # First separate the path from the arguments. This will split at the first
19596   # space.
19597   complete="$FOUND_MAKE"
19598   path="${complete%% *}"
19599   tmp="$complete EOL"
19600   arguments="${tmp#* }"
19601 
19602   # Input might be given as Windows format, start by converting to
19603   # unix format.
19604   new_path="$path"
19605 
19606   windows_path="$new_path"
19607   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19608     unix_path=`$CYGPATH -u "$windows_path"`
19609     new_path="$unix_path"
19610   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19611     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19612     new_path="$unix_path"
19613   fi
19614 
19615 
19616   # Now try to locate executable using which
19617   new_path=`$WHICH "$new_path" 2> /dev/null`
19618 
19619   if test "x$new_path" = x; then
19620     # Oops. Which didn't find the executable.
19621     # The splitting of arguments from the executable at a space might have been incorrect,
19622     # since paths with space are more likely in Windows. Give it another try with the whole
19623     # argument.
19624     path="$complete"
19625     arguments="EOL"
19626     new_path="$path"
19627 
19628   windows_path="$new_path"
19629   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19630     unix_path=`$CYGPATH -u "$windows_path"`
19631     new_path="$unix_path"
19632   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19633     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19634     new_path="$unix_path"
19635   fi
19636 
19637 
19638     new_path=`$WHICH "$new_path" 2> /dev/null`
19639     # bat and cmd files are not always considered executable in MSYS causing which
19640     # to not find them
19641     if test "x$new_path" = x \
19642         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19643         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19644       new_path="$path"
19645 
19646   windows_path="$new_path"
19647   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19648     unix_path=`$CYGPATH -u "$windows_path"`
19649     new_path="$unix_path"
19650   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19651     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19652     new_path="$unix_path"
19653   fi
19654 
19655     fi
19656 
19657     if test "x$new_path" = x; then
19658       # It's still not found. Now this is an unrecoverable error.
19659       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19660 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19661       has_space=`$ECHO "$complete" | $GREP " "`
19662       if test "x$has_space" != x; then
19663         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19664 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19665       fi
19666       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19667     fi
19668   fi
19669 
19670   # Now new_path has a complete unix path to the binary
19671   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
19672     # Keep paths in /bin as-is, but remove trailing .exe if any
19673     new_path="${new_path/%.exe/}"
19674     # Do not save /bin paths to all_fixpath_prefixes!
19675   else
19676     # Not in mixed or Windows style, start by that.
19677     new_path=`cmd //c echo $new_path`
19678 
19679   input_path="$new_path"
19680   # Check if we need to convert this using DOS-style short mode. If the path
19681   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19682   # take no chances and rewrite it.
19683   # Note: m4 eats our [], so we need to use [ and ] instead.
19684   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19685   if test "x$has_forbidden_chars" != x; then
19686     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19687     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19688   fi
19689 
19690     # Output is in $new_path
19691 
19692   windows_path="$new_path"
19693   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19694     unix_path=`$CYGPATH -u "$windows_path"`
19695     new_path="$unix_path"
19696   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19697     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19698     new_path="$unix_path"
19699   fi
19700 
19701     # remove trailing .exe if any
19702     new_path="${new_path/%.exe/}"
19703 
19704     # Save the first 10 bytes of this path to the storage, so fixpath can work.
19705     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19706   fi
19707 
19708     else
19709       # We're on a unix platform. Hooray! :)
19710       # First separate the path from the arguments. This will split at the first
19711       # space.
19712       complete="$FOUND_MAKE"
19713       path="${complete%% *}"
19714       tmp="$complete EOL"
19715       arguments="${tmp#* }"
19716 
19717       # Cannot rely on the command "which" here since it doesn't always work.
19718       is_absolute_path=`$ECHO "$path" | $GREP ^/`
19719       if test -z "$is_absolute_path"; then
19720         # Path to executable is not absolute. Find it.
19721         IFS_save="$IFS"
19722         IFS=:
19723         for p in $PATH; do
19724           if test -f "$p/$path" && test -x "$p/$path"; then
19725             new_path="$p/$path"
19726             break
19727           fi
19728         done
19729         IFS="$IFS_save"
19730       else
19731         # This is an absolute path, we can use it without further modifications.
19732         new_path="$path"
19733       fi
19734 
19735       if test "x$new_path" = x; then
19736         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19737 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19738         has_space=`$ECHO "$complete" | $GREP " "`
19739         if test "x$has_space" != x; then
19740           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
19741 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
19742         fi
19743         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19744       fi
19745     fi
19746 
19747     # Now join together the path and the arguments once again
19748     if test "x$arguments" != xEOL; then
19749       new_complete="$new_path ${arguments% *}"
19750     else
19751       new_complete="$new_path"
19752     fi
19753 
19754     if test "x$complete" != "x$new_complete"; then
19755       FOUND_MAKE="$new_complete"
19756       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
19757 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
19758     fi
19759   fi
19760 
19761         fi
19762       fi
19763     fi
19764   fi
19765 
19766         if test "x$FOUND_MAKE" = x; then
19767           for ac_prog in make
19768 do
19769   # Extract the first word of "$ac_prog", so it can be a program name with args.
19770 set dummy $ac_prog; ac_word=$2
19771 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19772 $as_echo_n "checking for $ac_word... " >&6; }
19773 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
19774   $as_echo_n "(cached) " >&6
19775 else
19776   case $CHECK_TOOLSDIR_MAKE in
19777   [\\/]* | ?:[\\/]*)
19778   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
19779   ;;
19780   *)
19781   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19782 for as_dir in $PATH
19783 do
19784   IFS=$as_save_IFS
19785   test -z "$as_dir" && as_dir=.
19786     for ac_exec_ext in '' $ac_executable_extensions; do
19787   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19788     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
19789     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19790     break 2
19791   fi
19792 done
19793   done
19794 IFS=$as_save_IFS
19795 
19796   ;;
19797 esac
19798 fi
19799 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
19800 if test -n "$CHECK_TOOLSDIR_MAKE"; then
19801   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
19802 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
19803 else
19804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19805 $as_echo "no" >&6; }
19806 fi
19807 
19808 
19809   test -n "$CHECK_TOOLSDIR_MAKE" && break
19810 done
19811 
19812 
19813   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
19814   DESCRIPTION="make in tools-dir"
19815 
19816   # On Cygwin, we require a newer version of make than on other platforms
19817   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19818     MAKE_VERSION_EXPR="-e 4\."
19819     MAKE_REQUIRED_VERSION="4.0"
19820    else
19821     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
19822     MAKE_REQUIRED_VERSION="3.81"
19823   fi
19824 
19825   if test "x$MAKE_CANDIDATE" != x; then
19826     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
19827 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
19828     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
19829     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
19830     if test "x$IS_GNU_MAKE" = x; then
19831       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
19832 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
19833     else
19834       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
19835       if test "x$IS_MODERN_MAKE" = x; then
19836         { $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
19837 $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;}
19838       else
19839         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
19840           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19841             MAKE_EXPECTED_ENV='cygwin'
19842           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19843             MAKE_EXPECTED_ENV='msys'
19844           else
19845             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
19846           fi
19847           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
19848           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
19849         else
19850           # Not relevant for non-Windows
19851           IS_MAKE_CORRECT_ENV=true
19852         fi
19853         if test "x$IS_MAKE_CORRECT_ENV" = x; then
19854           { $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
19855 $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;}
19856         else
19857           FOUND_MAKE=$MAKE_CANDIDATE
19858 
19859   # Only process if variable expands to non-empty
19860 
19861   if test "x$FOUND_MAKE" != x; then
19862     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19863 
19864   # First separate the path from the arguments. This will split at the first
19865   # space.
19866   complete="$FOUND_MAKE"
19867   path="${complete%% *}"
19868   tmp="$complete EOL"
19869   arguments="${tmp#* }"
19870 
19871   # Input might be given as Windows format, start by converting to
19872   # unix format.
19873   new_path=`$CYGPATH -u "$path"`
19874 
19875   # Now try to locate executable using which
19876   new_path=`$WHICH "$new_path" 2> /dev/null`
19877   # bat and cmd files are not always considered executable in cygwin causing which
19878   # to not find them
19879   if test "x$new_path" = x \
19880       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19881       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19882     new_path=`$CYGPATH -u "$path"`
19883   fi
19884   if test "x$new_path" = x; then
19885     # Oops. Which didn't find the executable.
19886     # The splitting of arguments from the executable at a space might have been incorrect,
19887     # since paths with space are more likely in Windows. Give it another try with the whole
19888     # argument.
19889     path="$complete"
19890     arguments="EOL"
19891     new_path=`$CYGPATH -u "$path"`
19892     new_path=`$WHICH "$new_path" 2> /dev/null`
19893     # bat and cmd files are not always considered executable in cygwin causing which
19894     # to not find them
19895     if test "x$new_path" = x \
19896         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
19897         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
19898       new_path=`$CYGPATH -u "$path"`
19899     fi
19900     if test "x$new_path" = x; then
19901       # It's still not found. Now this is an unrecoverable error.
19902       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
19903 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
19904       has_space=`$ECHO "$complete" | $GREP " "`
19905       if test "x$has_space" != x; then
19906         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
19907 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
19908       fi
19909       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19910     fi
19911   fi
19912 
19913   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19914   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19915   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19916   # "foo.exe" is OK but "foo" is an error.
19917   #
19918   # This test is therefore slightly more accurate than "test -f" to check for file presence.
19919   # It is also a way to make sure we got the proper file name for the real test later on.
19920   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19921   if test "x$test_shortpath" = x; then
19922     # Short path failed, file does not exist as specified.
19923     # Try adding .exe or .cmd
19924     if test -f "${new_path}.exe"; then
19925       input_to_shortpath="${new_path}.exe"
19926     elif test -f "${new_path}.cmd"; then
19927       input_to_shortpath="${new_path}.cmd"
19928     else
19929       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
19930 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
19931       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
19932 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
19933       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
19934     fi
19935   else
19936     input_to_shortpath="$new_path"
19937   fi
19938 
19939   # Call helper function which possibly converts this using DOS-style short mode.
19940   # If so, the updated path is stored in $new_path.
19941   new_path="$input_to_shortpath"
19942 
19943   input_path="$input_to_shortpath"
19944   # Check if we need to convert this using DOS-style short mode. If the path
19945   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19946   # take no chances and rewrite it.
19947   # Note: m4 eats our [], so we need to use [ and ] instead.
19948   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19949   if test "x$has_forbidden_chars" != x; then
19950     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19951     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19952     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19953     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19954       # Going to short mode and back again did indeed matter. Since short mode is
19955       # case insensitive, let's make it lowercase to improve readability.
19956       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19957       # Now convert it back to Unix-style (cygpath)
19958       input_path=`$CYGPATH -u "$shortmode_path"`
19959       new_path="$input_path"
19960     fi
19961   fi
19962 
19963   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19964   if test "x$test_cygdrive_prefix" = x; then
19965     # As a simple fix, exclude /usr/bin since it's not a real path.
19966     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
19967       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19968       # a path prefixed by /cygdrive for fixpath to work.
19969       new_path="$CYGWIN_ROOT_PATH$input_path"
19970     fi
19971   fi
19972 
19973   # remove trailing .exe if any
19974   new_path="${new_path/%.exe/}"
19975 
19976     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19977 
19978   # First separate the path from the arguments. This will split at the first
19979   # space.
19980   complete="$FOUND_MAKE"
19981   path="${complete%% *}"
19982   tmp="$complete EOL"
19983   arguments="${tmp#* }"
19984 
19985   # Input might be given as Windows format, start by converting to
19986   # unix format.
19987   new_path="$path"
19988 
19989   windows_path="$new_path"
19990   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19991     unix_path=`$CYGPATH -u "$windows_path"`
19992     new_path="$unix_path"
19993   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19994     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19995     new_path="$unix_path"
19996   fi
19997 
19998 
19999   # Now try to locate executable using which
20000   new_path=`$WHICH "$new_path" 2> /dev/null`
20001 
20002   if test "x$new_path" = x; then
20003     # Oops. Which didn't find the executable.
20004     # The splitting of arguments from the executable at a space might have been incorrect,
20005     # since paths with space are more likely in Windows. Give it another try with the whole
20006     # argument.
20007     path="$complete"
20008     arguments="EOL"
20009     new_path="$path"
20010 
20011   windows_path="$new_path"
20012   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20013     unix_path=`$CYGPATH -u "$windows_path"`
20014     new_path="$unix_path"
20015   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20016     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20017     new_path="$unix_path"
20018   fi
20019 
20020 
20021     new_path=`$WHICH "$new_path" 2> /dev/null`
20022     # bat and cmd files are not always considered executable in MSYS causing which
20023     # to not find them
20024     if test "x$new_path" = x \
20025         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20026         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20027       new_path="$path"
20028 
20029   windows_path="$new_path"
20030   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20031     unix_path=`$CYGPATH -u "$windows_path"`
20032     new_path="$unix_path"
20033   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20034     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20035     new_path="$unix_path"
20036   fi
20037 
20038     fi
20039 
20040     if test "x$new_path" = x; then
20041       # It's still not found. Now this is an unrecoverable error.
20042       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20043 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20044       has_space=`$ECHO "$complete" | $GREP " "`
20045       if test "x$has_space" != x; then
20046         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20047 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20048       fi
20049       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20050     fi
20051   fi
20052 
20053   # Now new_path has a complete unix path to the binary
20054   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20055     # Keep paths in /bin as-is, but remove trailing .exe if any
20056     new_path="${new_path/%.exe/}"
20057     # Do not save /bin paths to all_fixpath_prefixes!
20058   else
20059     # Not in mixed or Windows style, start by that.
20060     new_path=`cmd //c echo $new_path`
20061 
20062   input_path="$new_path"
20063   # Check if we need to convert this using DOS-style short mode. If the path
20064   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20065   # take no chances and rewrite it.
20066   # Note: m4 eats our [], so we need to use [ and ] instead.
20067   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20068   if test "x$has_forbidden_chars" != x; then
20069     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20070     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20071   fi
20072 
20073     # Output is in $new_path
20074 
20075   windows_path="$new_path"
20076   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20077     unix_path=`$CYGPATH -u "$windows_path"`
20078     new_path="$unix_path"
20079   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20080     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20081     new_path="$unix_path"
20082   fi
20083 
20084     # remove trailing .exe if any
20085     new_path="${new_path/%.exe/}"
20086 
20087     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20088     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20089   fi
20090 
20091     else
20092       # We're on a unix platform. Hooray! :)
20093       # First separate the path from the arguments. This will split at the first
20094       # space.
20095       complete="$FOUND_MAKE"
20096       path="${complete%% *}"
20097       tmp="$complete EOL"
20098       arguments="${tmp#* }"
20099 
20100       # Cannot rely on the command "which" here since it doesn't always work.
20101       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20102       if test -z "$is_absolute_path"; then
20103         # Path to executable is not absolute. Find it.
20104         IFS_save="$IFS"
20105         IFS=:
20106         for p in $PATH; do
20107           if test -f "$p/$path" && test -x "$p/$path"; then
20108             new_path="$p/$path"
20109             break
20110           fi
20111         done
20112         IFS="$IFS_save"
20113       else
20114         # This is an absolute path, we can use it without further modifications.
20115         new_path="$path"
20116       fi
20117 
20118       if test "x$new_path" = x; then
20119         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20120 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20121         has_space=`$ECHO "$complete" | $GREP " "`
20122         if test "x$has_space" != x; then
20123           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20124 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20125         fi
20126         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20127       fi
20128     fi
20129 
20130     # Now join together the path and the arguments once again
20131     if test "x$arguments" != xEOL; then
20132       new_complete="$new_path ${arguments% *}"
20133     else
20134       new_complete="$new_path"
20135     fi
20136 
20137     if test "x$complete" != "x$new_complete"; then
20138       FOUND_MAKE="$new_complete"
20139       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20140 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20141     fi
20142   fi
20143 
20144         fi
20145       fi
20146     fi
20147   fi
20148 
20149         fi
20150         PATH=$OLD_PATH
20151       fi
20152     fi
20153 
20154     if test "x$FOUND_MAKE" = x; then
20155       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
20156     fi
20157 
20158     else
20159       # If it succeeded, then it was overridden by the user. We will use it
20160       # for the tool.
20161 
20162       # First remove it from the list of overridden variables, so we can test
20163       # for unknown variables in the end.
20164       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20165 
20166       # Check if we try to supply an empty value
20167       if test "x$MAKE" = x; then
20168         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
20169 $as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
20170         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20171 $as_echo_n "checking for MAKE... " >&6; }
20172         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20173 $as_echo "disabled" >&6; }
20174       else
20175         # Check if the provided tool contains a complete path.
20176         tool_specified="$MAKE"
20177         tool_basename="${tool_specified##*/}"
20178         if test "x$tool_basename" = "x$tool_specified"; then
20179           # A command without a complete path is provided, search $PATH.
20180           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
20181 $as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
20182           # Extract the first word of "$tool_basename", so it can be a program name with args.
20183 set dummy $tool_basename; ac_word=$2
20184 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20185 $as_echo_n "checking for $ac_word... " >&6; }
20186 if ${ac_cv_path_MAKE+:} false; then :
20187   $as_echo_n "(cached) " >&6
20188 else
20189   case $MAKE in
20190   [\\/]* | ?:[\\/]*)
20191   ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
20192   ;;
20193   *)
20194   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20195 for as_dir in $PATH
20196 do
20197   IFS=$as_save_IFS
20198   test -z "$as_dir" && as_dir=.
20199     for ac_exec_ext in '' $ac_executable_extensions; do
20200   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20201     ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
20202     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20203     break 2
20204   fi
20205 done
20206   done
20207 IFS=$as_save_IFS
20208 
20209   ;;
20210 esac
20211 fi
20212 MAKE=$ac_cv_path_MAKE
20213 if test -n "$MAKE"; then
20214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
20215 $as_echo "$MAKE" >&6; }
20216 else
20217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20218 $as_echo "no" >&6; }
20219 fi
20220 
20221 
20222           if test "x$MAKE" = x; then
20223             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20224           fi
20225         else
20226           # Otherwise we believe it is a complete path. Use it as it is.
20227           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
20228 $as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
20229           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
20230 $as_echo_n "checking for MAKE... " >&6; }
20231           if test ! -x "$tool_specified"; then
20232             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20233 $as_echo "not found" >&6; }
20234             as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
20235           fi
20236           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20237 $as_echo "$tool_specified" >&6; }
20238         fi
20239       fi
20240     fi
20241 
20242     # If MAKE was set by user, verify the version
20243 
20244   MAKE_CANDIDATE=""$MAKE""
20245   DESCRIPTION="user supplied MAKE=$MAKE"
20246 
20247   # On Cygwin, we require a newer version of make than on other platforms
20248   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20249     MAKE_VERSION_EXPR="-e 4\."
20250     MAKE_REQUIRED_VERSION="4.0"
20251    else
20252     MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
20253     MAKE_REQUIRED_VERSION="3.81"
20254   fi
20255 
20256   if test "x$MAKE_CANDIDATE" != x; then
20257     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
20258 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
20259     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
20260     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
20261     if test "x$IS_GNU_MAKE" = x; then
20262       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
20263 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
20264     else
20265       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
20266       if test "x$IS_MODERN_MAKE" = x; then
20267         { $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
20268 $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;}
20269       else
20270         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
20271           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20272             MAKE_EXPECTED_ENV='cygwin'
20273           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20274             MAKE_EXPECTED_ENV='msys'
20275           else
20276             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
20277           fi
20278           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
20279           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
20280         else
20281           # Not relevant for non-Windows
20282           IS_MAKE_CORRECT_ENV=true
20283         fi
20284         if test "x$IS_MAKE_CORRECT_ENV" = x; then
20285           { $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
20286 $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;}
20287         else
20288           FOUND_MAKE=$MAKE_CANDIDATE
20289 
20290   # Only process if variable expands to non-empty
20291 
20292   if test "x$FOUND_MAKE" != x; then
20293     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20294 
20295   # First separate the path from the arguments. This will split at the first
20296   # space.
20297   complete="$FOUND_MAKE"
20298   path="${complete%% *}"
20299   tmp="$complete EOL"
20300   arguments="${tmp#* }"
20301 
20302   # Input might be given as Windows format, start by converting to
20303   # unix format.
20304   new_path=`$CYGPATH -u "$path"`
20305 
20306   # Now try to locate executable using which
20307   new_path=`$WHICH "$new_path" 2> /dev/null`
20308   # bat and cmd files are not always considered executable in cygwin causing which
20309   # to not find them
20310   if test "x$new_path" = x \
20311       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20312       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20313     new_path=`$CYGPATH -u "$path"`
20314   fi
20315   if test "x$new_path" = x; then
20316     # Oops. Which didn't find the executable.
20317     # The splitting of arguments from the executable at a space might have been incorrect,
20318     # since paths with space are more likely in Windows. Give it another try with the whole
20319     # argument.
20320     path="$complete"
20321     arguments="EOL"
20322     new_path=`$CYGPATH -u "$path"`
20323     new_path=`$WHICH "$new_path" 2> /dev/null`
20324     # bat and cmd files are not always considered executable in cygwin causing which
20325     # to not find them
20326     if test "x$new_path" = x \
20327         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20328         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20329       new_path=`$CYGPATH -u "$path"`
20330     fi
20331     if test "x$new_path" = x; then
20332       # It's still not found. Now this is an unrecoverable error.
20333       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20334 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20335       has_space=`$ECHO "$complete" | $GREP " "`
20336       if test "x$has_space" != x; then
20337         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20338 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20339       fi
20340       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20341     fi
20342   fi
20343 
20344   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20345   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20346   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20347   # "foo.exe" is OK but "foo" is an error.
20348   #
20349   # This test is therefore slightly more accurate than "test -f" to check for file presence.
20350   # It is also a way to make sure we got the proper file name for the real test later on.
20351   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20352   if test "x$test_shortpath" = x; then
20353     # Short path failed, file does not exist as specified.
20354     # Try adding .exe or .cmd
20355     if test -f "${new_path}.exe"; then
20356       input_to_shortpath="${new_path}.exe"
20357     elif test -f "${new_path}.cmd"; then
20358       input_to_shortpath="${new_path}.cmd"
20359     else
20360       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
20361 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
20362       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
20363 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
20364       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20365     fi
20366   else
20367     input_to_shortpath="$new_path"
20368   fi
20369 
20370   # Call helper function which possibly converts this using DOS-style short mode.
20371   # If so, the updated path is stored in $new_path.
20372   new_path="$input_to_shortpath"
20373 
20374   input_path="$input_to_shortpath"
20375   # Check if we need to convert this using DOS-style short mode. If the path
20376   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20377   # take no chances and rewrite it.
20378   # Note: m4 eats our [], so we need to use [ and ] instead.
20379   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20380   if test "x$has_forbidden_chars" != x; then
20381     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20382     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20383     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20384     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20385       # Going to short mode and back again did indeed matter. Since short mode is
20386       # case insensitive, let's make it lowercase to improve readability.
20387       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20388       # Now convert it back to Unix-style (cygpath)
20389       input_path=`$CYGPATH -u "$shortmode_path"`
20390       new_path="$input_path"
20391     fi
20392   fi
20393 
20394   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20395   if test "x$test_cygdrive_prefix" = x; then
20396     # As a simple fix, exclude /usr/bin since it's not a real path.
20397     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
20398       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20399       # a path prefixed by /cygdrive for fixpath to work.
20400       new_path="$CYGWIN_ROOT_PATH$input_path"
20401     fi
20402   fi
20403 
20404   # remove trailing .exe if any
20405   new_path="${new_path/%.exe/}"
20406 
20407     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20408 
20409   # First separate the path from the arguments. This will split at the first
20410   # space.
20411   complete="$FOUND_MAKE"
20412   path="${complete%% *}"
20413   tmp="$complete EOL"
20414   arguments="${tmp#* }"
20415 
20416   # Input might be given as Windows format, start by converting to
20417   # unix format.
20418   new_path="$path"
20419 
20420   windows_path="$new_path"
20421   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20422     unix_path=`$CYGPATH -u "$windows_path"`
20423     new_path="$unix_path"
20424   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20425     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20426     new_path="$unix_path"
20427   fi
20428 
20429 
20430   # Now try to locate executable using which
20431   new_path=`$WHICH "$new_path" 2> /dev/null`
20432 
20433   if test "x$new_path" = x; then
20434     # Oops. Which didn't find the executable.
20435     # The splitting of arguments from the executable at a space might have been incorrect,
20436     # since paths with space are more likely in Windows. Give it another try with the whole
20437     # argument.
20438     path="$complete"
20439     arguments="EOL"
20440     new_path="$path"
20441 
20442   windows_path="$new_path"
20443   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20444     unix_path=`$CYGPATH -u "$windows_path"`
20445     new_path="$unix_path"
20446   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20447     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20448     new_path="$unix_path"
20449   fi
20450 
20451 
20452     new_path=`$WHICH "$new_path" 2> /dev/null`
20453     # bat and cmd files are not always considered executable in MSYS causing which
20454     # to not find them
20455     if test "x$new_path" = x \
20456         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
20457         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
20458       new_path="$path"
20459 
20460   windows_path="$new_path"
20461   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20462     unix_path=`$CYGPATH -u "$windows_path"`
20463     new_path="$unix_path"
20464   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20465     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20466     new_path="$unix_path"
20467   fi
20468 
20469     fi
20470 
20471     if test "x$new_path" = x; then
20472       # It's still not found. Now this is an unrecoverable error.
20473       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20474 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20475       has_space=`$ECHO "$complete" | $GREP " "`
20476       if test "x$has_space" != x; then
20477         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
20478 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
20479       fi
20480       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20481     fi
20482   fi
20483 
20484   # Now new_path has a complete unix path to the binary
20485   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
20486     # Keep paths in /bin as-is, but remove trailing .exe if any
20487     new_path="${new_path/%.exe/}"
20488     # Do not save /bin paths to all_fixpath_prefixes!
20489   else
20490     # Not in mixed or Windows style, start by that.
20491     new_path=`cmd //c echo $new_path`
20492 
20493   input_path="$new_path"
20494   # Check if we need to convert this using DOS-style short mode. If the path
20495   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20496   # take no chances and rewrite it.
20497   # Note: m4 eats our [], so we need to use [ and ] instead.
20498   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20499   if test "x$has_forbidden_chars" != x; then
20500     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20501     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20502   fi
20503 
20504     # Output is in $new_path
20505 
20506   windows_path="$new_path"
20507   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20508     unix_path=`$CYGPATH -u "$windows_path"`
20509     new_path="$unix_path"
20510   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20511     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20512     new_path="$unix_path"
20513   fi
20514 
20515     # remove trailing .exe if any
20516     new_path="${new_path/%.exe/}"
20517 
20518     # Save the first 10 bytes of this path to the storage, so fixpath can work.
20519     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20520   fi
20521 
20522     else
20523       # We're on a unix platform. Hooray! :)
20524       # First separate the path from the arguments. This will split at the first
20525       # space.
20526       complete="$FOUND_MAKE"
20527       path="${complete%% *}"
20528       tmp="$complete EOL"
20529       arguments="${tmp#* }"
20530 
20531       # Cannot rely on the command "which" here since it doesn't always work.
20532       is_absolute_path=`$ECHO "$path" | $GREP ^/`
20533       if test -z "$is_absolute_path"; then
20534         # Path to executable is not absolute. Find it.
20535         IFS_save="$IFS"
20536         IFS=:
20537         for p in $PATH; do
20538           if test -f "$p/$path" && test -x "$p/$path"; then
20539             new_path="$p/$path"
20540             break
20541           fi
20542         done
20543         IFS="$IFS_save"
20544       else
20545         # This is an absolute path, we can use it without further modifications.
20546         new_path="$path"
20547       fi
20548 
20549       if test "x$new_path" = x; then
20550         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
20551 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
20552         has_space=`$ECHO "$complete" | $GREP " "`
20553         if test "x$has_space" != x; then
20554           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
20555 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
20556         fi
20557         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
20558       fi
20559     fi
20560 
20561     # Now join together the path and the arguments once again
20562     if test "x$arguments" != xEOL; then
20563       new_complete="$new_path ${arguments% *}"
20564     else
20565       new_complete="$new_path"
20566     fi
20567 
20568     if test "x$complete" != "x$new_complete"; then
20569       FOUND_MAKE="$new_complete"
20570       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
20571 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
20572     fi
20573   fi
20574 
20575         fi
20576       fi
20577     fi
20578   fi
20579 
20580     if test "x$FOUND_MAKE" = x; then
20581       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
20582     fi
20583 
20584   fi
20585 
20586 
20587   MAKE=$FOUND_MAKE
20588 
20589   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
20590 $as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
20591 
20592 
20593   # Check if make supports the output sync option and if so, setup using it.
20594   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
20595 $as_echo_n "checking if make --output-sync is supported... " >&6; }
20596   if $MAKE --version -O > /dev/null 2>&1; then
20597     OUTPUT_SYNC_SUPPORTED=true
20598     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20599 $as_echo "yes" >&6; }
20600     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
20601 $as_echo_n "checking for output-sync value... " >&6; }
20602 
20603 # Check whether --with-output-sync was given.
20604 if test "${with_output_sync+set}" = set; then :
20605   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
20606 fi
20607 
20608     if test "x$OUTPUT_SYNC" = "x"; then
20609       OUTPUT_SYNC=none
20610     fi
20611     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
20612 $as_echo "$OUTPUT_SYNC" >&6; }
20613     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
20614       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
20615     fi
20616   else
20617     OUTPUT_SYNC_SUPPORTED=false
20618     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20619 $as_echo "no" >&6; }
20620   fi
20621 
20622 
20623 
20624 
20625 
20626 
20627   # Test if find supports -delete
20628   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
20629 $as_echo_n "checking if find supports -delete... " >&6; }
20630   FIND_DELETE="-delete"
20631 
20632   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
20633 
20634   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
20635 
20636   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
20637   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
20638     # No, it does not.
20639     rm $DELETEDIR/TestIfFindSupportsDelete
20640     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
20641       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
20642       FIND_DELETE="-print | xargs rm"
20643     else
20644       FIND_DELETE="-exec rm \{\} \+"
20645     fi
20646     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20647 $as_echo "no" >&6; }
20648   else
20649     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
20650 $as_echo "yes" >&6; }
20651   fi
20652   rmdir $DELETEDIR
20653 
20654 
20655 
20656   # These tools might not be installed by default,
20657   # need hint on how to install them.
20658 
20659 
20660 
20661   # Publish this variable in the help.
20662 
20663 
20664   if [ -z "${UNZIP+x}" ]; then
20665     # The variable is not set by user, try to locate tool using the code snippet
20666     for ac_prog in unzip
20667 do
20668   # Extract the first word of "$ac_prog", so it can be a program name with args.
20669 set dummy $ac_prog; ac_word=$2
20670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20671 $as_echo_n "checking for $ac_word... " >&6; }
20672 if ${ac_cv_path_UNZIP+:} false; then :
20673   $as_echo_n "(cached) " >&6
20674 else
20675   case $UNZIP in
20676   [\\/]* | ?:[\\/]*)
20677   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20678   ;;
20679   *)
20680   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20681 for as_dir in $PATH
20682 do
20683   IFS=$as_save_IFS
20684   test -z "$as_dir" && as_dir=.
20685     for ac_exec_ext in '' $ac_executable_extensions; do
20686   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20687     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20688     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20689     break 2
20690   fi
20691 done
20692   done
20693 IFS=$as_save_IFS
20694 
20695   ;;
20696 esac
20697 fi
20698 UNZIP=$ac_cv_path_UNZIP
20699 if test -n "$UNZIP"; then
20700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20701 $as_echo "$UNZIP" >&6; }
20702 else
20703   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20704 $as_echo "no" >&6; }
20705 fi
20706 
20707 
20708   test -n "$UNZIP" && break
20709 done
20710 
20711   else
20712     # The variable is set, but is it from the command line or the environment?
20713 
20714     # Try to remove the string !UNZIP! from our list.
20715     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
20716     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20717       # If it failed, the variable was not from the command line. Ignore it,
20718       # but warn the user (except for BASH, which is always set by the calling BASH).
20719       if test "xUNZIP" != xBASH; then
20720         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
20721 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
20722       fi
20723       # Try to locate tool using the code snippet
20724       for ac_prog in unzip
20725 do
20726   # Extract the first word of "$ac_prog", so it can be a program name with args.
20727 set dummy $ac_prog; ac_word=$2
20728 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20729 $as_echo_n "checking for $ac_word... " >&6; }
20730 if ${ac_cv_path_UNZIP+:} false; then :
20731   $as_echo_n "(cached) " >&6
20732 else
20733   case $UNZIP in
20734   [\\/]* | ?:[\\/]*)
20735   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20736   ;;
20737   *)
20738   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20739 for as_dir in $PATH
20740 do
20741   IFS=$as_save_IFS
20742   test -z "$as_dir" && as_dir=.
20743     for ac_exec_ext in '' $ac_executable_extensions; do
20744   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20745     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20746     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20747     break 2
20748   fi
20749 done
20750   done
20751 IFS=$as_save_IFS
20752 
20753   ;;
20754 esac
20755 fi
20756 UNZIP=$ac_cv_path_UNZIP
20757 if test -n "$UNZIP"; then
20758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20759 $as_echo "$UNZIP" >&6; }
20760 else
20761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20762 $as_echo "no" >&6; }
20763 fi
20764 
20765 
20766   test -n "$UNZIP" && break
20767 done
20768 
20769     else
20770       # If it succeeded, then it was overridden by the user. We will use it
20771       # for the tool.
20772 
20773       # First remove it from the list of overridden variables, so we can test
20774       # for unknown variables in the end.
20775       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20776 
20777       # Check if we try to supply an empty value
20778       if test "x$UNZIP" = x; then
20779         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
20780 $as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
20781         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20782 $as_echo_n "checking for UNZIP... " >&6; }
20783         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20784 $as_echo "disabled" >&6; }
20785       else
20786         # Check if the provided tool contains a complete path.
20787         tool_specified="$UNZIP"
20788         tool_basename="${tool_specified##*/}"
20789         if test "x$tool_basename" = "x$tool_specified"; then
20790           # A command without a complete path is provided, search $PATH.
20791           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
20792 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
20793           # Extract the first word of "$tool_basename", so it can be a program name with args.
20794 set dummy $tool_basename; ac_word=$2
20795 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20796 $as_echo_n "checking for $ac_word... " >&6; }
20797 if ${ac_cv_path_UNZIP+:} false; then :
20798   $as_echo_n "(cached) " >&6
20799 else
20800   case $UNZIP in
20801   [\\/]* | ?:[\\/]*)
20802   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
20803   ;;
20804   *)
20805   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20806 for as_dir in $PATH
20807 do
20808   IFS=$as_save_IFS
20809   test -z "$as_dir" && as_dir=.
20810     for ac_exec_ext in '' $ac_executable_extensions; do
20811   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20812     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
20813     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20814     break 2
20815   fi
20816 done
20817   done
20818 IFS=$as_save_IFS
20819 
20820   ;;
20821 esac
20822 fi
20823 UNZIP=$ac_cv_path_UNZIP
20824 if test -n "$UNZIP"; then
20825   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
20826 $as_echo "$UNZIP" >&6; }
20827 else
20828   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20829 $as_echo "no" >&6; }
20830 fi
20831 
20832 
20833           if test "x$UNZIP" = x; then
20834             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
20835           fi
20836         else
20837           # Otherwise we believe it is a complete path. Use it as it is.
20838           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
20839 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
20840           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
20841 $as_echo_n "checking for UNZIP... " >&6; }
20842           if test ! -x "$tool_specified"; then
20843             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
20844 $as_echo "not found" >&6; }
20845             as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
20846           fi
20847           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
20848 $as_echo "$tool_specified" >&6; }
20849         fi
20850       fi
20851     fi
20852 
20853   fi
20854 
20855 
20856 
20857   if test "x$UNZIP" = x; then
20858     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
20859   fi
20860 
20861 
20862 
20863 
20864 
20865   # Publish this variable in the help.
20866 
20867 
20868   if [ -z "${ZIP+x}" ]; then
20869     # The variable is not set by user, try to locate tool using the code snippet
20870     for ac_prog in zip
20871 do
20872   # Extract the first word of "$ac_prog", so it can be a program name with args.
20873 set dummy $ac_prog; ac_word=$2
20874 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20875 $as_echo_n "checking for $ac_word... " >&6; }
20876 if ${ac_cv_path_ZIP+:} false; then :
20877   $as_echo_n "(cached) " >&6
20878 else
20879   case $ZIP in
20880   [\\/]* | ?:[\\/]*)
20881   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20882   ;;
20883   *)
20884   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20885 for as_dir in $PATH
20886 do
20887   IFS=$as_save_IFS
20888   test -z "$as_dir" && as_dir=.
20889     for ac_exec_ext in '' $ac_executable_extensions; do
20890   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20891     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20892     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20893     break 2
20894   fi
20895 done
20896   done
20897 IFS=$as_save_IFS
20898 
20899   ;;
20900 esac
20901 fi
20902 ZIP=$ac_cv_path_ZIP
20903 if test -n "$ZIP"; then
20904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20905 $as_echo "$ZIP" >&6; }
20906 else
20907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20908 $as_echo "no" >&6; }
20909 fi
20910 
20911 
20912   test -n "$ZIP" && break
20913 done
20914 
20915   else
20916     # The variable is set, but is it from the command line or the environment?
20917 
20918     # Try to remove the string !ZIP! from our list.
20919     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
20920     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
20921       # If it failed, the variable was not from the command line. Ignore it,
20922       # but warn the user (except for BASH, which is always set by the calling BASH).
20923       if test "xZIP" != xBASH; then
20924         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
20925 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
20926       fi
20927       # Try to locate tool using the code snippet
20928       for ac_prog in zip
20929 do
20930   # Extract the first word of "$ac_prog", so it can be a program name with args.
20931 set dummy $ac_prog; ac_word=$2
20932 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
20933 $as_echo_n "checking for $ac_word... " >&6; }
20934 if ${ac_cv_path_ZIP+:} false; then :
20935   $as_echo_n "(cached) " >&6
20936 else
20937   case $ZIP in
20938   [\\/]* | ?:[\\/]*)
20939   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
20940   ;;
20941   *)
20942   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20943 for as_dir in $PATH
20944 do
20945   IFS=$as_save_IFS
20946   test -z "$as_dir" && as_dir=.
20947     for ac_exec_ext in '' $ac_executable_extensions; do
20948   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
20949     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
20950     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
20951     break 2
20952   fi
20953 done
20954   done
20955 IFS=$as_save_IFS
20956 
20957   ;;
20958 esac
20959 fi
20960 ZIP=$ac_cv_path_ZIP
20961 if test -n "$ZIP"; then
20962   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
20963 $as_echo "$ZIP" >&6; }
20964 else
20965   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
20966 $as_echo "no" >&6; }
20967 fi
20968 
20969 
20970   test -n "$ZIP" && break
20971 done
20972 
20973     else
20974       # If it succeeded, then it was overridden by the user. We will use it
20975       # for the tool.
20976 
20977       # First remove it from the list of overridden variables, so we can test
20978       # for unknown variables in the end.
20979       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
20980 
20981       # Check if we try to supply an empty value
20982       if test "x$ZIP" = x; then
20983         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIP= (no value)" >&5
20984 $as_echo "$as_me: Setting user supplied tool ZIP= (no value)" >&6;}
20985         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
20986 $as_echo_n "checking for ZIP... " >&6; }
20987         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
20988 $as_echo "disabled" >&6; }
20989       else
20990         # Check if the provided tool contains a complete path.
20991         tool_specified="$ZIP"
20992         tool_basename="${tool_specified##*/}"
20993         if test "x$tool_basename" = "x$tool_specified"; then
20994           # A command without a complete path is provided, search $PATH.
20995           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
20996 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
20997           # Extract the first word of "$tool_basename", so it can be a program name with args.
20998 set dummy $tool_basename; ac_word=$2
20999 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21000 $as_echo_n "checking for $ac_word... " >&6; }
21001 if ${ac_cv_path_ZIP+:} false; then :
21002   $as_echo_n "(cached) " >&6
21003 else
21004   case $ZIP in
21005   [\\/]* | ?:[\\/]*)
21006   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
21007   ;;
21008   *)
21009   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21010 for as_dir in $PATH
21011 do
21012   IFS=$as_save_IFS
21013   test -z "$as_dir" && as_dir=.
21014     for ac_exec_ext in '' $ac_executable_extensions; do
21015   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21016     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
21017     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21018     break 2
21019   fi
21020 done
21021   done
21022 IFS=$as_save_IFS
21023 
21024   ;;
21025 esac
21026 fi
21027 ZIP=$ac_cv_path_ZIP
21028 if test -n "$ZIP"; then
21029   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
21030 $as_echo "$ZIP" >&6; }
21031 else
21032   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21033 $as_echo "no" >&6; }
21034 fi
21035 
21036 
21037           if test "x$ZIP" = x; then
21038             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21039           fi
21040         else
21041           # Otherwise we believe it is a complete path. Use it as it is.
21042           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
21043 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
21044           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
21045 $as_echo_n "checking for ZIP... " >&6; }
21046           if test ! -x "$tool_specified"; then
21047             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21048 $as_echo "not found" >&6; }
21049             as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
21050           fi
21051           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21052 $as_echo "$tool_specified" >&6; }
21053         fi
21054       fi
21055     fi
21056 
21057   fi
21058 
21059 
21060 
21061   if test "x$ZIP" = x; then
21062     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
21063   fi
21064 
21065 
21066 
21067   # Non-required basic tools
21068 
21069 
21070 
21071   # Publish this variable in the help.
21072 
21073 
21074   if [ -z "${LDD+x}" ]; then
21075     # The variable is not set by user, try to locate tool using the code snippet
21076     for ac_prog in ldd
21077 do
21078   # Extract the first word of "$ac_prog", so it can be a program name with args.
21079 set dummy $ac_prog; ac_word=$2
21080 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21081 $as_echo_n "checking for $ac_word... " >&6; }
21082 if ${ac_cv_path_LDD+:} false; then :
21083   $as_echo_n "(cached) " >&6
21084 else
21085   case $LDD in
21086   [\\/]* | ?:[\\/]*)
21087   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21088   ;;
21089   *)
21090   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21091 for as_dir in $PATH
21092 do
21093   IFS=$as_save_IFS
21094   test -z "$as_dir" && as_dir=.
21095     for ac_exec_ext in '' $ac_executable_extensions; do
21096   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21097     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21098     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21099     break 2
21100   fi
21101 done
21102   done
21103 IFS=$as_save_IFS
21104 
21105   ;;
21106 esac
21107 fi
21108 LDD=$ac_cv_path_LDD
21109 if test -n "$LDD"; then
21110   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21111 $as_echo "$LDD" >&6; }
21112 else
21113   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21114 $as_echo "no" >&6; }
21115 fi
21116 
21117 
21118   test -n "$LDD" && break
21119 done
21120 
21121   else
21122     # The variable is set, but is it from the command line or the environment?
21123 
21124     # Try to remove the string !LDD! from our list.
21125     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
21126     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21127       # If it failed, the variable was not from the command line. Ignore it,
21128       # but warn the user (except for BASH, which is always set by the calling BASH).
21129       if test "xLDD" != xBASH; then
21130         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
21131 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
21132       fi
21133       # Try to locate tool using the code snippet
21134       for ac_prog in ldd
21135 do
21136   # Extract the first word of "$ac_prog", so it can be a program name with args.
21137 set dummy $ac_prog; ac_word=$2
21138 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21139 $as_echo_n "checking for $ac_word... " >&6; }
21140 if ${ac_cv_path_LDD+:} false; then :
21141   $as_echo_n "(cached) " >&6
21142 else
21143   case $LDD in
21144   [\\/]* | ?:[\\/]*)
21145   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21146   ;;
21147   *)
21148   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21149 for as_dir in $PATH
21150 do
21151   IFS=$as_save_IFS
21152   test -z "$as_dir" && as_dir=.
21153     for ac_exec_ext in '' $ac_executable_extensions; do
21154   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21155     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21156     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21157     break 2
21158   fi
21159 done
21160   done
21161 IFS=$as_save_IFS
21162 
21163   ;;
21164 esac
21165 fi
21166 LDD=$ac_cv_path_LDD
21167 if test -n "$LDD"; then
21168   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21169 $as_echo "$LDD" >&6; }
21170 else
21171   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21172 $as_echo "no" >&6; }
21173 fi
21174 
21175 
21176   test -n "$LDD" && break
21177 done
21178 
21179     else
21180       # If it succeeded, then it was overridden by the user. We will use it
21181       # for the tool.
21182 
21183       # First remove it from the list of overridden variables, so we can test
21184       # for unknown variables in the end.
21185       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21186 
21187       # Check if we try to supply an empty value
21188       if test "x$LDD" = x; then
21189         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
21190 $as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
21191         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21192 $as_echo_n "checking for LDD... " >&6; }
21193         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21194 $as_echo "disabled" >&6; }
21195       else
21196         # Check if the provided tool contains a complete path.
21197         tool_specified="$LDD"
21198         tool_basename="${tool_specified##*/}"
21199         if test "x$tool_basename" = "x$tool_specified"; then
21200           # A command without a complete path is provided, search $PATH.
21201           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
21202 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
21203           # Extract the first word of "$tool_basename", so it can be a program name with args.
21204 set dummy $tool_basename; ac_word=$2
21205 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21206 $as_echo_n "checking for $ac_word... " >&6; }
21207 if ${ac_cv_path_LDD+:} false; then :
21208   $as_echo_n "(cached) " >&6
21209 else
21210   case $LDD in
21211   [\\/]* | ?:[\\/]*)
21212   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
21213   ;;
21214   *)
21215   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21216 for as_dir in $PATH
21217 do
21218   IFS=$as_save_IFS
21219   test -z "$as_dir" && as_dir=.
21220     for ac_exec_ext in '' $ac_executable_extensions; do
21221   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21222     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
21223     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21224     break 2
21225   fi
21226 done
21227   done
21228 IFS=$as_save_IFS
21229 
21230   ;;
21231 esac
21232 fi
21233 LDD=$ac_cv_path_LDD
21234 if test -n "$LDD"; then
21235   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
21236 $as_echo "$LDD" >&6; }
21237 else
21238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21239 $as_echo "no" >&6; }
21240 fi
21241 
21242 
21243           if test "x$LDD" = x; then
21244             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21245           fi
21246         else
21247           # Otherwise we believe it is a complete path. Use it as it is.
21248           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
21249 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
21250           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
21251 $as_echo_n "checking for LDD... " >&6; }
21252           if test ! -x "$tool_specified"; then
21253             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21254 $as_echo "not found" >&6; }
21255             as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
21256           fi
21257           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21258 $as_echo "$tool_specified" >&6; }
21259         fi
21260       fi
21261     fi
21262 
21263   fi
21264 
21265 
21266   if test "x$LDD" = "x"; then
21267     # List shared lib dependencies is used for
21268     # debug output and checking for forbidden dependencies.
21269     # We can build without it.
21270     LDD="true"
21271   fi
21272 
21273 
21274   # Publish this variable in the help.
21275 
21276 
21277   if [ -z "${OTOOL+x}" ]; then
21278     # The variable is not set by user, try to locate tool using the code snippet
21279     for ac_prog in otool
21280 do
21281   # Extract the first word of "$ac_prog", so it can be a program name with args.
21282 set dummy $ac_prog; ac_word=$2
21283 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21284 $as_echo_n "checking for $ac_word... " >&6; }
21285 if ${ac_cv_path_OTOOL+:} false; then :
21286   $as_echo_n "(cached) " >&6
21287 else
21288   case $OTOOL in
21289   [\\/]* | ?:[\\/]*)
21290   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21291   ;;
21292   *)
21293   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21294 for as_dir in $PATH
21295 do
21296   IFS=$as_save_IFS
21297   test -z "$as_dir" && as_dir=.
21298     for ac_exec_ext in '' $ac_executable_extensions; do
21299   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21300     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21301     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21302     break 2
21303   fi
21304 done
21305   done
21306 IFS=$as_save_IFS
21307 
21308   ;;
21309 esac
21310 fi
21311 OTOOL=$ac_cv_path_OTOOL
21312 if test -n "$OTOOL"; then
21313   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21314 $as_echo "$OTOOL" >&6; }
21315 else
21316   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21317 $as_echo "no" >&6; }
21318 fi
21319 
21320 
21321   test -n "$OTOOL" && break
21322 done
21323 
21324   else
21325     # The variable is set, but is it from the command line or the environment?
21326 
21327     # Try to remove the string !OTOOL! from our list.
21328     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
21329     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21330       # If it failed, the variable was not from the command line. Ignore it,
21331       # but warn the user (except for BASH, which is always set by the calling BASH).
21332       if test "xOTOOL" != xBASH; then
21333         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
21334 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
21335       fi
21336       # Try to locate tool using the code snippet
21337       for ac_prog in otool
21338 do
21339   # Extract the first word of "$ac_prog", so it can be a program name with args.
21340 set dummy $ac_prog; ac_word=$2
21341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21342 $as_echo_n "checking for $ac_word... " >&6; }
21343 if ${ac_cv_path_OTOOL+:} false; then :
21344   $as_echo_n "(cached) " >&6
21345 else
21346   case $OTOOL in
21347   [\\/]* | ?:[\\/]*)
21348   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21349   ;;
21350   *)
21351   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21352 for as_dir in $PATH
21353 do
21354   IFS=$as_save_IFS
21355   test -z "$as_dir" && as_dir=.
21356     for ac_exec_ext in '' $ac_executable_extensions; do
21357   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21358     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21359     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21360     break 2
21361   fi
21362 done
21363   done
21364 IFS=$as_save_IFS
21365 
21366   ;;
21367 esac
21368 fi
21369 OTOOL=$ac_cv_path_OTOOL
21370 if test -n "$OTOOL"; then
21371   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21372 $as_echo "$OTOOL" >&6; }
21373 else
21374   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21375 $as_echo "no" >&6; }
21376 fi
21377 
21378 
21379   test -n "$OTOOL" && break
21380 done
21381 
21382     else
21383       # If it succeeded, then it was overridden by the user. We will use it
21384       # for the tool.
21385 
21386       # First remove it from the list of overridden variables, so we can test
21387       # for unknown variables in the end.
21388       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21389 
21390       # Check if we try to supply an empty value
21391       if test "x$OTOOL" = x; then
21392         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
21393 $as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
21394         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21395 $as_echo_n "checking for OTOOL... " >&6; }
21396         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21397 $as_echo "disabled" >&6; }
21398       else
21399         # Check if the provided tool contains a complete path.
21400         tool_specified="$OTOOL"
21401         tool_basename="${tool_specified##*/}"
21402         if test "x$tool_basename" = "x$tool_specified"; then
21403           # A command without a complete path is provided, search $PATH.
21404           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
21405 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
21406           # Extract the first word of "$tool_basename", so it can be a program name with args.
21407 set dummy $tool_basename; ac_word=$2
21408 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21409 $as_echo_n "checking for $ac_word... " >&6; }
21410 if ${ac_cv_path_OTOOL+:} false; then :
21411   $as_echo_n "(cached) " >&6
21412 else
21413   case $OTOOL in
21414   [\\/]* | ?:[\\/]*)
21415   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
21416   ;;
21417   *)
21418   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21419 for as_dir in $PATH
21420 do
21421   IFS=$as_save_IFS
21422   test -z "$as_dir" && as_dir=.
21423     for ac_exec_ext in '' $ac_executable_extensions; do
21424   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21425     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
21426     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21427     break 2
21428   fi
21429 done
21430   done
21431 IFS=$as_save_IFS
21432 
21433   ;;
21434 esac
21435 fi
21436 OTOOL=$ac_cv_path_OTOOL
21437 if test -n "$OTOOL"; then
21438   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
21439 $as_echo "$OTOOL" >&6; }
21440 else
21441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21442 $as_echo "no" >&6; }
21443 fi
21444 
21445 
21446           if test "x$OTOOL" = x; then
21447             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21448           fi
21449         else
21450           # Otherwise we believe it is a complete path. Use it as it is.
21451           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
21452 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
21453           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
21454 $as_echo_n "checking for OTOOL... " >&6; }
21455           if test ! -x "$tool_specified"; then
21456             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21457 $as_echo "not found" >&6; }
21458             as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
21459           fi
21460           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21461 $as_echo "$tool_specified" >&6; }
21462         fi
21463       fi
21464     fi
21465 
21466   fi
21467 
21468 
21469   if test "x$OTOOL" = "x"; then
21470     OTOOL="true"
21471   fi
21472 
21473 
21474   # Publish this variable in the help.
21475 
21476 
21477   if [ -z "${READELF+x}" ]; then
21478     # The variable is not set by user, try to locate tool using the code snippet
21479     for ac_prog in greadelf readelf
21480 do
21481   # Extract the first word of "$ac_prog", so it can be a program name with args.
21482 set dummy $ac_prog; ac_word=$2
21483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21484 $as_echo_n "checking for $ac_word... " >&6; }
21485 if ${ac_cv_path_READELF+:} false; then :
21486   $as_echo_n "(cached) " >&6
21487 else
21488   case $READELF in
21489   [\\/]* | ?:[\\/]*)
21490   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21491   ;;
21492   *)
21493   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21494 for as_dir in $PATH
21495 do
21496   IFS=$as_save_IFS
21497   test -z "$as_dir" && as_dir=.
21498     for ac_exec_ext in '' $ac_executable_extensions; do
21499   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21500     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21501     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21502     break 2
21503   fi
21504 done
21505   done
21506 IFS=$as_save_IFS
21507 
21508   ;;
21509 esac
21510 fi
21511 READELF=$ac_cv_path_READELF
21512 if test -n "$READELF"; then
21513   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21514 $as_echo "$READELF" >&6; }
21515 else
21516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21517 $as_echo "no" >&6; }
21518 fi
21519 
21520 
21521   test -n "$READELF" && break
21522 done
21523 
21524   else
21525     # The variable is set, but is it from the command line or the environment?
21526 
21527     # Try to remove the string !READELF! from our list.
21528     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
21529     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21530       # If it failed, the variable was not from the command line. Ignore it,
21531       # but warn the user (except for BASH, which is always set by the calling BASH).
21532       if test "xREADELF" != xBASH; then
21533         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
21534 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
21535       fi
21536       # Try to locate tool using the code snippet
21537       for ac_prog in greadelf readelf
21538 do
21539   # Extract the first word of "$ac_prog", so it can be a program name with args.
21540 set dummy $ac_prog; ac_word=$2
21541 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21542 $as_echo_n "checking for $ac_word... " >&6; }
21543 if ${ac_cv_path_READELF+:} false; then :
21544   $as_echo_n "(cached) " >&6
21545 else
21546   case $READELF in
21547   [\\/]* | ?:[\\/]*)
21548   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21549   ;;
21550   *)
21551   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21552 for as_dir in $PATH
21553 do
21554   IFS=$as_save_IFS
21555   test -z "$as_dir" && as_dir=.
21556     for ac_exec_ext in '' $ac_executable_extensions; do
21557   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21558     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21559     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21560     break 2
21561   fi
21562 done
21563   done
21564 IFS=$as_save_IFS
21565 
21566   ;;
21567 esac
21568 fi
21569 READELF=$ac_cv_path_READELF
21570 if test -n "$READELF"; then
21571   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21572 $as_echo "$READELF" >&6; }
21573 else
21574   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21575 $as_echo "no" >&6; }
21576 fi
21577 
21578 
21579   test -n "$READELF" && break
21580 done
21581 
21582     else
21583       # If it succeeded, then it was overridden by the user. We will use it
21584       # for the tool.
21585 
21586       # First remove it from the list of overridden variables, so we can test
21587       # for unknown variables in the end.
21588       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21589 
21590       # Check if we try to supply an empty value
21591       if test "x$READELF" = x; then
21592         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
21593 $as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
21594         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21595 $as_echo_n "checking for READELF... " >&6; }
21596         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21597 $as_echo "disabled" >&6; }
21598       else
21599         # Check if the provided tool contains a complete path.
21600         tool_specified="$READELF"
21601         tool_basename="${tool_specified##*/}"
21602         if test "x$tool_basename" = "x$tool_specified"; then
21603           # A command without a complete path is provided, search $PATH.
21604           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
21605 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
21606           # Extract the first word of "$tool_basename", so it can be a program name with args.
21607 set dummy $tool_basename; ac_word=$2
21608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21609 $as_echo_n "checking for $ac_word... " >&6; }
21610 if ${ac_cv_path_READELF+:} false; then :
21611   $as_echo_n "(cached) " >&6
21612 else
21613   case $READELF in
21614   [\\/]* | ?:[\\/]*)
21615   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
21616   ;;
21617   *)
21618   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21619 for as_dir in $PATH
21620 do
21621   IFS=$as_save_IFS
21622   test -z "$as_dir" && as_dir=.
21623     for ac_exec_ext in '' $ac_executable_extensions; do
21624   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21625     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
21626     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21627     break 2
21628   fi
21629 done
21630   done
21631 IFS=$as_save_IFS
21632 
21633   ;;
21634 esac
21635 fi
21636 READELF=$ac_cv_path_READELF
21637 if test -n "$READELF"; then
21638   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
21639 $as_echo "$READELF" >&6; }
21640 else
21641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21642 $as_echo "no" >&6; }
21643 fi
21644 
21645 
21646           if test "x$READELF" = x; then
21647             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21648           fi
21649         else
21650           # Otherwise we believe it is a complete path. Use it as it is.
21651           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
21652 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
21653           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
21654 $as_echo_n "checking for READELF... " >&6; }
21655           if test ! -x "$tool_specified"; then
21656             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21657 $as_echo "not found" >&6; }
21658             as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
21659           fi
21660           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21661 $as_echo "$tool_specified" >&6; }
21662         fi
21663       fi
21664     fi
21665 
21666   fi
21667 
21668 
21669 
21670 
21671   # Publish this variable in the help.
21672 
21673 
21674   if [ -z "${HG+x}" ]; then
21675     # The variable is not set by user, try to locate tool using the code snippet
21676     for ac_prog in hg
21677 do
21678   # Extract the first word of "$ac_prog", so it can be a program name with args.
21679 set dummy $ac_prog; ac_word=$2
21680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21681 $as_echo_n "checking for $ac_word... " >&6; }
21682 if ${ac_cv_path_HG+:} false; then :
21683   $as_echo_n "(cached) " >&6
21684 else
21685   case $HG in
21686   [\\/]* | ?:[\\/]*)
21687   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21688   ;;
21689   *)
21690   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21691 for as_dir in $PATH
21692 do
21693   IFS=$as_save_IFS
21694   test -z "$as_dir" && as_dir=.
21695     for ac_exec_ext in '' $ac_executable_extensions; do
21696   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21697     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21698     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21699     break 2
21700   fi
21701 done
21702   done
21703 IFS=$as_save_IFS
21704 
21705   ;;
21706 esac
21707 fi
21708 HG=$ac_cv_path_HG
21709 if test -n "$HG"; then
21710   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21711 $as_echo "$HG" >&6; }
21712 else
21713   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21714 $as_echo "no" >&6; }
21715 fi
21716 
21717 
21718   test -n "$HG" && break
21719 done
21720 
21721   else
21722     # The variable is set, but is it from the command line or the environment?
21723 
21724     # Try to remove the string !HG! from our list.
21725     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
21726     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21727       # If it failed, the variable was not from the command line. Ignore it,
21728       # but warn the user (except for BASH, which is always set by the calling BASH).
21729       if test "xHG" != xBASH; then
21730         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
21731 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
21732       fi
21733       # Try to locate tool using the code snippet
21734       for ac_prog in hg
21735 do
21736   # Extract the first word of "$ac_prog", so it can be a program name with args.
21737 set dummy $ac_prog; ac_word=$2
21738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21739 $as_echo_n "checking for $ac_word... " >&6; }
21740 if ${ac_cv_path_HG+:} false; then :
21741   $as_echo_n "(cached) " >&6
21742 else
21743   case $HG in
21744   [\\/]* | ?:[\\/]*)
21745   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21746   ;;
21747   *)
21748   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21749 for as_dir in $PATH
21750 do
21751   IFS=$as_save_IFS
21752   test -z "$as_dir" && as_dir=.
21753     for ac_exec_ext in '' $ac_executable_extensions; do
21754   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21755     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21756     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21757     break 2
21758   fi
21759 done
21760   done
21761 IFS=$as_save_IFS
21762 
21763   ;;
21764 esac
21765 fi
21766 HG=$ac_cv_path_HG
21767 if test -n "$HG"; then
21768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21769 $as_echo "$HG" >&6; }
21770 else
21771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21772 $as_echo "no" >&6; }
21773 fi
21774 
21775 
21776   test -n "$HG" && break
21777 done
21778 
21779     else
21780       # If it succeeded, then it was overridden by the user. We will use it
21781       # for the tool.
21782 
21783       # First remove it from the list of overridden variables, so we can test
21784       # for unknown variables in the end.
21785       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21786 
21787       # Check if we try to supply an empty value
21788       if test "x$HG" = x; then
21789         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
21790 $as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
21791         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21792 $as_echo_n "checking for HG... " >&6; }
21793         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21794 $as_echo "disabled" >&6; }
21795       else
21796         # Check if the provided tool contains a complete path.
21797         tool_specified="$HG"
21798         tool_basename="${tool_specified##*/}"
21799         if test "x$tool_basename" = "x$tool_specified"; then
21800           # A command without a complete path is provided, search $PATH.
21801           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
21802 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
21803           # Extract the first word of "$tool_basename", so it can be a program name with args.
21804 set dummy $tool_basename; ac_word=$2
21805 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21806 $as_echo_n "checking for $ac_word... " >&6; }
21807 if ${ac_cv_path_HG+:} false; then :
21808   $as_echo_n "(cached) " >&6
21809 else
21810   case $HG in
21811   [\\/]* | ?:[\\/]*)
21812   ac_cv_path_HG="$HG" # Let the user override the test with a path.
21813   ;;
21814   *)
21815   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21816 for as_dir in $PATH
21817 do
21818   IFS=$as_save_IFS
21819   test -z "$as_dir" && as_dir=.
21820     for ac_exec_ext in '' $ac_executable_extensions; do
21821   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21822     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
21823     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21824     break 2
21825   fi
21826 done
21827   done
21828 IFS=$as_save_IFS
21829 
21830   ;;
21831 esac
21832 fi
21833 HG=$ac_cv_path_HG
21834 if test -n "$HG"; then
21835   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
21836 $as_echo "$HG" >&6; }
21837 else
21838   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21839 $as_echo "no" >&6; }
21840 fi
21841 
21842 
21843           if test "x$HG" = x; then
21844             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
21845           fi
21846         else
21847           # Otherwise we believe it is a complete path. Use it as it is.
21848           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
21849 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
21850           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
21851 $as_echo_n "checking for HG... " >&6; }
21852           if test ! -x "$tool_specified"; then
21853             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
21854 $as_echo "not found" >&6; }
21855             as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
21856           fi
21857           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
21858 $as_echo "$tool_specified" >&6; }
21859         fi
21860       fi
21861     fi
21862 
21863   fi
21864 
21865 
21866 
21867 
21868   # Publish this variable in the help.
21869 
21870 
21871   if [ -z "${STAT+x}" ]; then
21872     # The variable is not set by user, try to locate tool using the code snippet
21873     for ac_prog in stat
21874 do
21875   # Extract the first word of "$ac_prog", so it can be a program name with args.
21876 set dummy $ac_prog; ac_word=$2
21877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21878 $as_echo_n "checking for $ac_word... " >&6; }
21879 if ${ac_cv_path_STAT+:} false; then :
21880   $as_echo_n "(cached) " >&6
21881 else
21882   case $STAT in
21883   [\\/]* | ?:[\\/]*)
21884   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21885   ;;
21886   *)
21887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21888 for as_dir in $PATH
21889 do
21890   IFS=$as_save_IFS
21891   test -z "$as_dir" && as_dir=.
21892     for ac_exec_ext in '' $ac_executable_extensions; do
21893   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21894     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21895     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21896     break 2
21897   fi
21898 done
21899   done
21900 IFS=$as_save_IFS
21901 
21902   ;;
21903 esac
21904 fi
21905 STAT=$ac_cv_path_STAT
21906 if test -n "$STAT"; then
21907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21908 $as_echo "$STAT" >&6; }
21909 else
21910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21911 $as_echo "no" >&6; }
21912 fi
21913 
21914 
21915   test -n "$STAT" && break
21916 done
21917 
21918   else
21919     # The variable is set, but is it from the command line or the environment?
21920 
21921     # Try to remove the string !STAT! from our list.
21922     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
21923     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
21924       # If it failed, the variable was not from the command line. Ignore it,
21925       # but warn the user (except for BASH, which is always set by the calling BASH).
21926       if test "xSTAT" != xBASH; then
21927         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
21928 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
21929       fi
21930       # Try to locate tool using the code snippet
21931       for ac_prog in stat
21932 do
21933   # Extract the first word of "$ac_prog", so it can be a program name with args.
21934 set dummy $ac_prog; ac_word=$2
21935 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21936 $as_echo_n "checking for $ac_word... " >&6; }
21937 if ${ac_cv_path_STAT+:} false; then :
21938   $as_echo_n "(cached) " >&6
21939 else
21940   case $STAT in
21941   [\\/]* | ?:[\\/]*)
21942   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
21943   ;;
21944   *)
21945   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21946 for as_dir in $PATH
21947 do
21948   IFS=$as_save_IFS
21949   test -z "$as_dir" && as_dir=.
21950     for ac_exec_ext in '' $ac_executable_extensions; do
21951   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21952     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
21953     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21954     break 2
21955   fi
21956 done
21957   done
21958 IFS=$as_save_IFS
21959 
21960   ;;
21961 esac
21962 fi
21963 STAT=$ac_cv_path_STAT
21964 if test -n "$STAT"; then
21965   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
21966 $as_echo "$STAT" >&6; }
21967 else
21968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21969 $as_echo "no" >&6; }
21970 fi
21971 
21972 
21973   test -n "$STAT" && break
21974 done
21975 
21976     else
21977       # If it succeeded, then it was overridden by the user. We will use it
21978       # for the tool.
21979 
21980       # First remove it from the list of overridden variables, so we can test
21981       # for unknown variables in the end.
21982       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
21983 
21984       # Check if we try to supply an empty value
21985       if test "x$STAT" = x; then
21986         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
21987 $as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
21988         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
21989 $as_echo_n "checking for STAT... " >&6; }
21990         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
21991 $as_echo "disabled" >&6; }
21992       else
21993         # Check if the provided tool contains a complete path.
21994         tool_specified="$STAT"
21995         tool_basename="${tool_specified##*/}"
21996         if test "x$tool_basename" = "x$tool_specified"; then
21997           # A command without a complete path is provided, search $PATH.
21998           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
21999 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
22000           # Extract the first word of "$tool_basename", so it can be a program name with args.
22001 set dummy $tool_basename; ac_word=$2
22002 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22003 $as_echo_n "checking for $ac_word... " >&6; }
22004 if ${ac_cv_path_STAT+:} false; then :
22005   $as_echo_n "(cached) " >&6
22006 else
22007   case $STAT in
22008   [\\/]* | ?:[\\/]*)
22009   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
22010   ;;
22011   *)
22012   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22013 for as_dir in $PATH
22014 do
22015   IFS=$as_save_IFS
22016   test -z "$as_dir" && as_dir=.
22017     for ac_exec_ext in '' $ac_executable_extensions; do
22018   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22019     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
22020     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22021     break 2
22022   fi
22023 done
22024   done
22025 IFS=$as_save_IFS
22026 
22027   ;;
22028 esac
22029 fi
22030 STAT=$ac_cv_path_STAT
22031 if test -n "$STAT"; then
22032   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
22033 $as_echo "$STAT" >&6; }
22034 else
22035   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22036 $as_echo "no" >&6; }
22037 fi
22038 
22039 
22040           if test "x$STAT" = x; then
22041             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22042           fi
22043         else
22044           # Otherwise we believe it is a complete path. Use it as it is.
22045           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
22046 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
22047           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
22048 $as_echo_n "checking for STAT... " >&6; }
22049           if test ! -x "$tool_specified"; then
22050             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22051 $as_echo "not found" >&6; }
22052             as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
22053           fi
22054           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22055 $as_echo "$tool_specified" >&6; }
22056         fi
22057       fi
22058     fi
22059 
22060   fi
22061 
22062 
22063 
22064 
22065   # Publish this variable in the help.
22066 
22067 
22068   if [ -z "${TIME+x}" ]; then
22069     # The variable is not set by user, try to locate tool using the code snippet
22070     for ac_prog in time
22071 do
22072   # Extract the first word of "$ac_prog", so it can be a program name with args.
22073 set dummy $ac_prog; ac_word=$2
22074 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22075 $as_echo_n "checking for $ac_word... " >&6; }
22076 if ${ac_cv_path_TIME+:} false; then :
22077   $as_echo_n "(cached) " >&6
22078 else
22079   case $TIME in
22080   [\\/]* | ?:[\\/]*)
22081   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22082   ;;
22083   *)
22084   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22085 for as_dir in $PATH
22086 do
22087   IFS=$as_save_IFS
22088   test -z "$as_dir" && as_dir=.
22089     for ac_exec_ext in '' $ac_executable_extensions; do
22090   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22091     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22092     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22093     break 2
22094   fi
22095 done
22096   done
22097 IFS=$as_save_IFS
22098 
22099   ;;
22100 esac
22101 fi
22102 TIME=$ac_cv_path_TIME
22103 if test -n "$TIME"; then
22104   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22105 $as_echo "$TIME" >&6; }
22106 else
22107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22108 $as_echo "no" >&6; }
22109 fi
22110 
22111 
22112   test -n "$TIME" && break
22113 done
22114 
22115   else
22116     # The variable is set, but is it from the command line or the environment?
22117 
22118     # Try to remove the string !TIME! from our list.
22119     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
22120     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22121       # If it failed, the variable was not from the command line. Ignore it,
22122       # but warn the user (except for BASH, which is always set by the calling BASH).
22123       if test "xTIME" != xBASH; then
22124         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
22125 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
22126       fi
22127       # Try to locate tool using the code snippet
22128       for ac_prog in time
22129 do
22130   # Extract the first word of "$ac_prog", so it can be a program name with args.
22131 set dummy $ac_prog; ac_word=$2
22132 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22133 $as_echo_n "checking for $ac_word... " >&6; }
22134 if ${ac_cv_path_TIME+:} false; then :
22135   $as_echo_n "(cached) " >&6
22136 else
22137   case $TIME in
22138   [\\/]* | ?:[\\/]*)
22139   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22140   ;;
22141   *)
22142   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22143 for as_dir in $PATH
22144 do
22145   IFS=$as_save_IFS
22146   test -z "$as_dir" && as_dir=.
22147     for ac_exec_ext in '' $ac_executable_extensions; do
22148   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22149     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22150     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22151     break 2
22152   fi
22153 done
22154   done
22155 IFS=$as_save_IFS
22156 
22157   ;;
22158 esac
22159 fi
22160 TIME=$ac_cv_path_TIME
22161 if test -n "$TIME"; then
22162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22163 $as_echo "$TIME" >&6; }
22164 else
22165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22166 $as_echo "no" >&6; }
22167 fi
22168 
22169 
22170   test -n "$TIME" && break
22171 done
22172 
22173     else
22174       # If it succeeded, then it was overridden by the user. We will use it
22175       # for the tool.
22176 
22177       # First remove it from the list of overridden variables, so we can test
22178       # for unknown variables in the end.
22179       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22180 
22181       # Check if we try to supply an empty value
22182       if test "x$TIME" = x; then
22183         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
22184 $as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
22185         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22186 $as_echo_n "checking for TIME... " >&6; }
22187         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22188 $as_echo "disabled" >&6; }
22189       else
22190         # Check if the provided tool contains a complete path.
22191         tool_specified="$TIME"
22192         tool_basename="${tool_specified##*/}"
22193         if test "x$tool_basename" = "x$tool_specified"; then
22194           # A command without a complete path is provided, search $PATH.
22195           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
22196 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
22197           # Extract the first word of "$tool_basename", so it can be a program name with args.
22198 set dummy $tool_basename; ac_word=$2
22199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22200 $as_echo_n "checking for $ac_word... " >&6; }
22201 if ${ac_cv_path_TIME+:} false; then :
22202   $as_echo_n "(cached) " >&6
22203 else
22204   case $TIME in
22205   [\\/]* | ?:[\\/]*)
22206   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
22207   ;;
22208   *)
22209   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22210 for as_dir in $PATH
22211 do
22212   IFS=$as_save_IFS
22213   test -z "$as_dir" && as_dir=.
22214     for ac_exec_ext in '' $ac_executable_extensions; do
22215   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22216     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
22217     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22218     break 2
22219   fi
22220 done
22221   done
22222 IFS=$as_save_IFS
22223 
22224   ;;
22225 esac
22226 fi
22227 TIME=$ac_cv_path_TIME
22228 if test -n "$TIME"; then
22229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
22230 $as_echo "$TIME" >&6; }
22231 else
22232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22233 $as_echo "no" >&6; }
22234 fi
22235 
22236 
22237           if test "x$TIME" = x; then
22238             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22239           fi
22240         else
22241           # Otherwise we believe it is a complete path. Use it as it is.
22242           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
22243 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
22244           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
22245 $as_echo_n "checking for TIME... " >&6; }
22246           if test ! -x "$tool_specified"; then
22247             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22248 $as_echo "not found" >&6; }
22249             as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
22250           fi
22251           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22252 $as_echo "$tool_specified" >&6; }
22253         fi
22254       fi
22255     fi
22256 
22257   fi
22258 
22259 
22260 
22261 
22262   # Publish this variable in the help.
22263 
22264 
22265   if [ -z "${DTRACE+x}" ]; then
22266     # The variable is not set by user, try to locate tool using the code snippet
22267     for ac_prog in dtrace
22268 do
22269   # Extract the first word of "$ac_prog", so it can be a program name with args.
22270 set dummy $ac_prog; ac_word=$2
22271 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22272 $as_echo_n "checking for $ac_word... " >&6; }
22273 if ${ac_cv_path_DTRACE+:} false; then :
22274   $as_echo_n "(cached) " >&6
22275 else
22276   case $DTRACE in
22277   [\\/]* | ?:[\\/]*)
22278   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22279   ;;
22280   *)
22281   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22282 for as_dir in $PATH
22283 do
22284   IFS=$as_save_IFS
22285   test -z "$as_dir" && as_dir=.
22286     for ac_exec_ext in '' $ac_executable_extensions; do
22287   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22288     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22289     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22290     break 2
22291   fi
22292 done
22293   done
22294 IFS=$as_save_IFS
22295 
22296   ;;
22297 esac
22298 fi
22299 DTRACE=$ac_cv_path_DTRACE
22300 if test -n "$DTRACE"; then
22301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22302 $as_echo "$DTRACE" >&6; }
22303 else
22304   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22305 $as_echo "no" >&6; }
22306 fi
22307 
22308 
22309   test -n "$DTRACE" && break
22310 done
22311 
22312   else
22313     # The variable is set, but is it from the command line or the environment?
22314 
22315     # Try to remove the string !DTRACE! from our list.
22316     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DTRACE!/}
22317     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22318       # If it failed, the variable was not from the command line. Ignore it,
22319       # but warn the user (except for BASH, which is always set by the calling BASH).
22320       if test "xDTRACE" != xBASH; then
22321         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&5
22322 $as_echo "$as_me: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&2;}
22323       fi
22324       # Try to locate tool using the code snippet
22325       for ac_prog in dtrace
22326 do
22327   # Extract the first word of "$ac_prog", so it can be a program name with args.
22328 set dummy $ac_prog; ac_word=$2
22329 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22330 $as_echo_n "checking for $ac_word... " >&6; }
22331 if ${ac_cv_path_DTRACE+:} false; then :
22332   $as_echo_n "(cached) " >&6
22333 else
22334   case $DTRACE in
22335   [\\/]* | ?:[\\/]*)
22336   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22337   ;;
22338   *)
22339   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22340 for as_dir in $PATH
22341 do
22342   IFS=$as_save_IFS
22343   test -z "$as_dir" && as_dir=.
22344     for ac_exec_ext in '' $ac_executable_extensions; do
22345   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22346     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22347     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22348     break 2
22349   fi
22350 done
22351   done
22352 IFS=$as_save_IFS
22353 
22354   ;;
22355 esac
22356 fi
22357 DTRACE=$ac_cv_path_DTRACE
22358 if test -n "$DTRACE"; then
22359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22360 $as_echo "$DTRACE" >&6; }
22361 else
22362   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22363 $as_echo "no" >&6; }
22364 fi
22365 
22366 
22367   test -n "$DTRACE" && break
22368 done
22369 
22370     else
22371       # If it succeeded, then it was overridden by the user. We will use it
22372       # for the tool.
22373 
22374       # First remove it from the list of overridden variables, so we can test
22375       # for unknown variables in the end.
22376       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22377 
22378       # Check if we try to supply an empty value
22379       if test "x$DTRACE" = x; then
22380         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DTRACE= (no value)" >&5
22381 $as_echo "$as_me: Setting user supplied tool DTRACE= (no value)" >&6;}
22382         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22383 $as_echo_n "checking for DTRACE... " >&6; }
22384         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22385 $as_echo "disabled" >&6; }
22386       else
22387         # Check if the provided tool contains a complete path.
22388         tool_specified="$DTRACE"
22389         tool_basename="${tool_specified##*/}"
22390         if test "x$tool_basename" = "x$tool_specified"; then
22391           # A command without a complete path is provided, search $PATH.
22392           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DTRACE=$tool_basename" >&5
22393 $as_echo "$as_me: Will search for user supplied tool DTRACE=$tool_basename" >&6;}
22394           # Extract the first word of "$tool_basename", so it can be a program name with args.
22395 set dummy $tool_basename; ac_word=$2
22396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22397 $as_echo_n "checking for $ac_word... " >&6; }
22398 if ${ac_cv_path_DTRACE+:} false; then :
22399   $as_echo_n "(cached) " >&6
22400 else
22401   case $DTRACE in
22402   [\\/]* | ?:[\\/]*)
22403   ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
22404   ;;
22405   *)
22406   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22407 for as_dir in $PATH
22408 do
22409   IFS=$as_save_IFS
22410   test -z "$as_dir" && as_dir=.
22411     for ac_exec_ext in '' $ac_executable_extensions; do
22412   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22413     ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
22414     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22415     break 2
22416   fi
22417 done
22418   done
22419 IFS=$as_save_IFS
22420 
22421   ;;
22422 esac
22423 fi
22424 DTRACE=$ac_cv_path_DTRACE
22425 if test -n "$DTRACE"; then
22426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
22427 $as_echo "$DTRACE" >&6; }
22428 else
22429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22430 $as_echo "no" >&6; }
22431 fi
22432 
22433 
22434           if test "x$DTRACE" = x; then
22435             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22436           fi
22437         else
22438           # Otherwise we believe it is a complete path. Use it as it is.
22439           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DTRACE=$tool_specified" >&5
22440 $as_echo "$as_me: Will use user supplied tool DTRACE=$tool_specified" >&6;}
22441           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
22442 $as_echo_n "checking for DTRACE... " >&6; }
22443           if test ! -x "$tool_specified"; then
22444             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22445 $as_echo "not found" >&6; }
22446             as_fn_error $? "User supplied tool DTRACE=$tool_specified does not exist or is not executable" "$LINENO" 5
22447           fi
22448           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22449 $as_echo "$tool_specified" >&6; }
22450         fi
22451       fi
22452     fi
22453 
22454   fi
22455 
22456 
22457 
22458 
22459   # Publish this variable in the help.
22460 
22461 
22462   if [ -z "${PATCH+x}" ]; then
22463     # The variable is not set by user, try to locate tool using the code snippet
22464     for ac_prog in gpatch patch
22465 do
22466   # Extract the first word of "$ac_prog", so it can be a program name with args.
22467 set dummy $ac_prog; ac_word=$2
22468 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22469 $as_echo_n "checking for $ac_word... " >&6; }
22470 if ${ac_cv_path_PATCH+:} false; then :
22471   $as_echo_n "(cached) " >&6
22472 else
22473   case $PATCH in
22474   [\\/]* | ?:[\\/]*)
22475   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22476   ;;
22477   *)
22478   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22479 for as_dir in $PATH
22480 do
22481   IFS=$as_save_IFS
22482   test -z "$as_dir" && as_dir=.
22483     for ac_exec_ext in '' $ac_executable_extensions; do
22484   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22485     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22486     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22487     break 2
22488   fi
22489 done
22490   done
22491 IFS=$as_save_IFS
22492 
22493   ;;
22494 esac
22495 fi
22496 PATCH=$ac_cv_path_PATCH
22497 if test -n "$PATCH"; then
22498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22499 $as_echo "$PATCH" >&6; }
22500 else
22501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22502 $as_echo "no" >&6; }
22503 fi
22504 
22505 
22506   test -n "$PATCH" && break
22507 done
22508 
22509   else
22510     # The variable is set, but is it from the command line or the environment?
22511 
22512     # Try to remove the string !PATCH! from our list.
22513     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
22514     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22515       # If it failed, the variable was not from the command line. Ignore it,
22516       # but warn the user (except for BASH, which is always set by the calling BASH).
22517       if test "xPATCH" != xBASH; then
22518         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
22519 $as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
22520       fi
22521       # Try to locate tool using the code snippet
22522       for ac_prog in gpatch patch
22523 do
22524   # Extract the first word of "$ac_prog", so it can be a program name with args.
22525 set dummy $ac_prog; ac_word=$2
22526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22527 $as_echo_n "checking for $ac_word... " >&6; }
22528 if ${ac_cv_path_PATCH+:} false; then :
22529   $as_echo_n "(cached) " >&6
22530 else
22531   case $PATCH in
22532   [\\/]* | ?:[\\/]*)
22533   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22534   ;;
22535   *)
22536   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22537 for as_dir in $PATH
22538 do
22539   IFS=$as_save_IFS
22540   test -z "$as_dir" && as_dir=.
22541     for ac_exec_ext in '' $ac_executable_extensions; do
22542   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22543     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22544     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22545     break 2
22546   fi
22547 done
22548   done
22549 IFS=$as_save_IFS
22550 
22551   ;;
22552 esac
22553 fi
22554 PATCH=$ac_cv_path_PATCH
22555 if test -n "$PATCH"; then
22556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22557 $as_echo "$PATCH" >&6; }
22558 else
22559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22560 $as_echo "no" >&6; }
22561 fi
22562 
22563 
22564   test -n "$PATCH" && break
22565 done
22566 
22567     else
22568       # If it succeeded, then it was overridden by the user. We will use it
22569       # for the tool.
22570 
22571       # First remove it from the list of overridden variables, so we can test
22572       # for unknown variables in the end.
22573       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22574 
22575       # Check if we try to supply an empty value
22576       if test "x$PATCH" = x; then
22577         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
22578 $as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
22579         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
22580 $as_echo_n "checking for PATCH... " >&6; }
22581         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22582 $as_echo "disabled" >&6; }
22583       else
22584         # Check if the provided tool contains a complete path.
22585         tool_specified="$PATCH"
22586         tool_basename="${tool_specified##*/}"
22587         if test "x$tool_basename" = "x$tool_specified"; then
22588           # A command without a complete path is provided, search $PATH.
22589           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
22590 $as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
22591           # Extract the first word of "$tool_basename", so it can be a program name with args.
22592 set dummy $tool_basename; ac_word=$2
22593 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22594 $as_echo_n "checking for $ac_word... " >&6; }
22595 if ${ac_cv_path_PATCH+:} false; then :
22596   $as_echo_n "(cached) " >&6
22597 else
22598   case $PATCH in
22599   [\\/]* | ?:[\\/]*)
22600   ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
22601   ;;
22602   *)
22603   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22604 for as_dir in $PATH
22605 do
22606   IFS=$as_save_IFS
22607   test -z "$as_dir" && as_dir=.
22608     for ac_exec_ext in '' $ac_executable_extensions; do
22609   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22610     ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
22611     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22612     break 2
22613   fi
22614 done
22615   done
22616 IFS=$as_save_IFS
22617 
22618   ;;
22619 esac
22620 fi
22621 PATCH=$ac_cv_path_PATCH
22622 if test -n "$PATCH"; then
22623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
22624 $as_echo "$PATCH" >&6; }
22625 else
22626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22627 $as_echo "no" >&6; }
22628 fi
22629 
22630 
22631           if test "x$PATCH" = x; then
22632             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22633           fi
22634         else
22635           # Otherwise we believe it is a complete path. Use it as it is.
22636           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
22637 $as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
22638           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
22639 $as_echo_n "checking for PATCH... " >&6; }
22640           if test ! -x "$tool_specified"; then
22641             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22642 $as_echo "not found" >&6; }
22643             as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
22644           fi
22645           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22646 $as_echo "$tool_specified" >&6; }
22647         fi
22648       fi
22649     fi
22650 
22651   fi
22652 
22653 
22654   # Check if it's GNU time
22655   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
22656   if test "x$IS_GNU_TIME" != x; then
22657     IS_GNU_TIME=yes
22658   else
22659     IS_GNU_TIME=no
22660   fi
22661 
22662 
22663   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
22664 
22665 
22666 
22667   # Publish this variable in the help.
22668 
22669 
22670   if [ -z "${DSYMUTIL+x}" ]; then
22671     # The variable is not set by user, try to locate tool using the code snippet
22672     for ac_prog in dsymutil
22673 do
22674   # Extract the first word of "$ac_prog", so it can be a program name with args.
22675 set dummy $ac_prog; ac_word=$2
22676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22677 $as_echo_n "checking for $ac_word... " >&6; }
22678 if ${ac_cv_path_DSYMUTIL+:} false; then :
22679   $as_echo_n "(cached) " >&6
22680 else
22681   case $DSYMUTIL in
22682   [\\/]* | ?:[\\/]*)
22683   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22684   ;;
22685   *)
22686   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22687 for as_dir in $PATH
22688 do
22689   IFS=$as_save_IFS
22690   test -z "$as_dir" && as_dir=.
22691     for ac_exec_ext in '' $ac_executable_extensions; do
22692   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22693     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22694     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22695     break 2
22696   fi
22697 done
22698   done
22699 IFS=$as_save_IFS
22700 
22701   ;;
22702 esac
22703 fi
22704 DSYMUTIL=$ac_cv_path_DSYMUTIL
22705 if test -n "$DSYMUTIL"; then
22706   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22707 $as_echo "$DSYMUTIL" >&6; }
22708 else
22709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22710 $as_echo "no" >&6; }
22711 fi
22712 
22713 
22714   test -n "$DSYMUTIL" && break
22715 done
22716 
22717   else
22718     # The variable is set, but is it from the command line or the environment?
22719 
22720     # Try to remove the string !DSYMUTIL! from our list.
22721     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
22722     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22723       # If it failed, the variable was not from the command line. Ignore it,
22724       # but warn the user (except for BASH, which is always set by the calling BASH).
22725       if test "xDSYMUTIL" != xBASH; then
22726         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
22727 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
22728       fi
22729       # Try to locate tool using the code snippet
22730       for ac_prog in dsymutil
22731 do
22732   # Extract the first word of "$ac_prog", so it can be a program name with args.
22733 set dummy $ac_prog; ac_word=$2
22734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22735 $as_echo_n "checking for $ac_word... " >&6; }
22736 if ${ac_cv_path_DSYMUTIL+:} false; then :
22737   $as_echo_n "(cached) " >&6
22738 else
22739   case $DSYMUTIL in
22740   [\\/]* | ?:[\\/]*)
22741   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22742   ;;
22743   *)
22744   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22745 for as_dir in $PATH
22746 do
22747   IFS=$as_save_IFS
22748   test -z "$as_dir" && as_dir=.
22749     for ac_exec_ext in '' $ac_executable_extensions; do
22750   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22751     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22752     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22753     break 2
22754   fi
22755 done
22756   done
22757 IFS=$as_save_IFS
22758 
22759   ;;
22760 esac
22761 fi
22762 DSYMUTIL=$ac_cv_path_DSYMUTIL
22763 if test -n "$DSYMUTIL"; then
22764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22765 $as_echo "$DSYMUTIL" >&6; }
22766 else
22767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22768 $as_echo "no" >&6; }
22769 fi
22770 
22771 
22772   test -n "$DSYMUTIL" && break
22773 done
22774 
22775     else
22776       # If it succeeded, then it was overridden by the user. We will use it
22777       # for the tool.
22778 
22779       # First remove it from the list of overridden variables, so we can test
22780       # for unknown variables in the end.
22781       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22782 
22783       # Check if we try to supply an empty value
22784       if test "x$DSYMUTIL" = x; then
22785         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
22786 $as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
22787         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22788 $as_echo_n "checking for DSYMUTIL... " >&6; }
22789         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22790 $as_echo "disabled" >&6; }
22791       else
22792         # Check if the provided tool contains a complete path.
22793         tool_specified="$DSYMUTIL"
22794         tool_basename="${tool_specified##*/}"
22795         if test "x$tool_basename" = "x$tool_specified"; then
22796           # A command without a complete path is provided, search $PATH.
22797           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
22798 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
22799           # Extract the first word of "$tool_basename", so it can be a program name with args.
22800 set dummy $tool_basename; ac_word=$2
22801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22802 $as_echo_n "checking for $ac_word... " >&6; }
22803 if ${ac_cv_path_DSYMUTIL+:} false; then :
22804   $as_echo_n "(cached) " >&6
22805 else
22806   case $DSYMUTIL in
22807   [\\/]* | ?:[\\/]*)
22808   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
22809   ;;
22810   *)
22811   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22812 for as_dir in $PATH
22813 do
22814   IFS=$as_save_IFS
22815   test -z "$as_dir" && as_dir=.
22816     for ac_exec_ext in '' $ac_executable_extensions; do
22817   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22818     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
22819     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22820     break 2
22821   fi
22822 done
22823   done
22824 IFS=$as_save_IFS
22825 
22826   ;;
22827 esac
22828 fi
22829 DSYMUTIL=$ac_cv_path_DSYMUTIL
22830 if test -n "$DSYMUTIL"; then
22831   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
22832 $as_echo "$DSYMUTIL" >&6; }
22833 else
22834   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22835 $as_echo "no" >&6; }
22836 fi
22837 
22838 
22839           if test "x$DSYMUTIL" = x; then
22840             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
22841           fi
22842         else
22843           # Otherwise we believe it is a complete path. Use it as it is.
22844           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
22845 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
22846           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
22847 $as_echo_n "checking for DSYMUTIL... " >&6; }
22848           if test ! -x "$tool_specified"; then
22849             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
22850 $as_echo "not found" >&6; }
22851             as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
22852           fi
22853           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
22854 $as_echo "$tool_specified" >&6; }
22855         fi
22856       fi
22857     fi
22858 
22859   fi
22860 
22861 
22862 
22863   if test "x$DSYMUTIL" = x; then
22864     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
22865   fi
22866 
22867 
22868 
22869 
22870 
22871   # Publish this variable in the help.
22872 
22873 
22874   if [ -z "${XATTR+x}" ]; then
22875     # The variable is not set by user, try to locate tool using the code snippet
22876     for ac_prog in xattr
22877 do
22878   # Extract the first word of "$ac_prog", so it can be a program name with args.
22879 set dummy $ac_prog; ac_word=$2
22880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22881 $as_echo_n "checking for $ac_word... " >&6; }
22882 if ${ac_cv_path_XATTR+:} false; then :
22883   $as_echo_n "(cached) " >&6
22884 else
22885   case $XATTR in
22886   [\\/]* | ?:[\\/]*)
22887   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22888   ;;
22889   *)
22890   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22891 for as_dir in $PATH
22892 do
22893   IFS=$as_save_IFS
22894   test -z "$as_dir" && as_dir=.
22895     for ac_exec_ext in '' $ac_executable_extensions; do
22896   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22897     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22898     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22899     break 2
22900   fi
22901 done
22902   done
22903 IFS=$as_save_IFS
22904 
22905   ;;
22906 esac
22907 fi
22908 XATTR=$ac_cv_path_XATTR
22909 if test -n "$XATTR"; then
22910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22911 $as_echo "$XATTR" >&6; }
22912 else
22913   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22914 $as_echo "no" >&6; }
22915 fi
22916 
22917 
22918   test -n "$XATTR" && break
22919 done
22920 
22921   else
22922     # The variable is set, but is it from the command line or the environment?
22923 
22924     # Try to remove the string !XATTR! from our list.
22925     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
22926     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
22927       # If it failed, the variable was not from the command line. Ignore it,
22928       # but warn the user (except for BASH, which is always set by the calling BASH).
22929       if test "xXATTR" != xBASH; then
22930         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
22931 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
22932       fi
22933       # Try to locate tool using the code snippet
22934       for ac_prog in xattr
22935 do
22936   # Extract the first word of "$ac_prog", so it can be a program name with args.
22937 set dummy $ac_prog; ac_word=$2
22938 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
22939 $as_echo_n "checking for $ac_word... " >&6; }
22940 if ${ac_cv_path_XATTR+:} false; then :
22941   $as_echo_n "(cached) " >&6
22942 else
22943   case $XATTR in
22944   [\\/]* | ?:[\\/]*)
22945   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
22946   ;;
22947   *)
22948   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
22949 for as_dir in $PATH
22950 do
22951   IFS=$as_save_IFS
22952   test -z "$as_dir" && as_dir=.
22953     for ac_exec_ext in '' $ac_executable_extensions; do
22954   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
22955     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
22956     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
22957     break 2
22958   fi
22959 done
22960   done
22961 IFS=$as_save_IFS
22962 
22963   ;;
22964 esac
22965 fi
22966 XATTR=$ac_cv_path_XATTR
22967 if test -n "$XATTR"; then
22968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
22969 $as_echo "$XATTR" >&6; }
22970 else
22971   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
22972 $as_echo "no" >&6; }
22973 fi
22974 
22975 
22976   test -n "$XATTR" && break
22977 done
22978 
22979     else
22980       # If it succeeded, then it was overridden by the user. We will use it
22981       # for the tool.
22982 
22983       # First remove it from the list of overridden variables, so we can test
22984       # for unknown variables in the end.
22985       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
22986 
22987       # Check if we try to supply an empty value
22988       if test "x$XATTR" = x; then
22989         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
22990 $as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
22991         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
22992 $as_echo_n "checking for XATTR... " >&6; }
22993         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
22994 $as_echo "disabled" >&6; }
22995       else
22996         # Check if the provided tool contains a complete path.
22997         tool_specified="$XATTR"
22998         tool_basename="${tool_specified##*/}"
22999         if test "x$tool_basename" = "x$tool_specified"; then
23000           # A command without a complete path is provided, search $PATH.
23001           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
23002 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
23003           # Extract the first word of "$tool_basename", so it can be a program name with args.
23004 set dummy $tool_basename; ac_word=$2
23005 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23006 $as_echo_n "checking for $ac_word... " >&6; }
23007 if ${ac_cv_path_XATTR+:} false; then :
23008   $as_echo_n "(cached) " >&6
23009 else
23010   case $XATTR in
23011   [\\/]* | ?:[\\/]*)
23012   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
23013   ;;
23014   *)
23015   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23016 for as_dir in $PATH
23017 do
23018   IFS=$as_save_IFS
23019   test -z "$as_dir" && as_dir=.
23020     for ac_exec_ext in '' $ac_executable_extensions; do
23021   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23022     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
23023     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23024     break 2
23025   fi
23026 done
23027   done
23028 IFS=$as_save_IFS
23029 
23030   ;;
23031 esac
23032 fi
23033 XATTR=$ac_cv_path_XATTR
23034 if test -n "$XATTR"; then
23035   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
23036 $as_echo "$XATTR" >&6; }
23037 else
23038   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23039 $as_echo "no" >&6; }
23040 fi
23041 
23042 
23043           if test "x$XATTR" = x; then
23044             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23045           fi
23046         else
23047           # Otherwise we believe it is a complete path. Use it as it is.
23048           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
23049 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
23050           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
23051 $as_echo_n "checking for XATTR... " >&6; }
23052           if test ! -x "$tool_specified"; then
23053             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23054 $as_echo "not found" >&6; }
23055             as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
23056           fi
23057           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23058 $as_echo "$tool_specified" >&6; }
23059         fi
23060       fi
23061     fi
23062 
23063   fi
23064 
23065 
23066 
23067   if test "x$XATTR" = x; then
23068     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
23069   fi
23070 
23071 
23072 
23073 
23074   # Publish this variable in the help.
23075 
23076 
23077   if [ -z "${CODESIGN+x}" ]; then
23078     # The variable is not set by user, try to locate tool using the code snippet
23079     for ac_prog in codesign
23080 do
23081   # Extract the first word of "$ac_prog", so it can be a program name with args.
23082 set dummy $ac_prog; ac_word=$2
23083 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23084 $as_echo_n "checking for $ac_word... " >&6; }
23085 if ${ac_cv_path_CODESIGN+:} false; then :
23086   $as_echo_n "(cached) " >&6
23087 else
23088   case $CODESIGN in
23089   [\\/]* | ?:[\\/]*)
23090   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23091   ;;
23092   *)
23093   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23094 for as_dir in $PATH
23095 do
23096   IFS=$as_save_IFS
23097   test -z "$as_dir" && as_dir=.
23098     for ac_exec_ext in '' $ac_executable_extensions; do
23099   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23100     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23101     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23102     break 2
23103   fi
23104 done
23105   done
23106 IFS=$as_save_IFS
23107 
23108   ;;
23109 esac
23110 fi
23111 CODESIGN=$ac_cv_path_CODESIGN
23112 if test -n "$CODESIGN"; then
23113   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23114 $as_echo "$CODESIGN" >&6; }
23115 else
23116   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23117 $as_echo "no" >&6; }
23118 fi
23119 
23120 
23121   test -n "$CODESIGN" && break
23122 done
23123 
23124   else
23125     # The variable is set, but is it from the command line or the environment?
23126 
23127     # Try to remove the string !CODESIGN! from our list.
23128     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
23129     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23130       # If it failed, the variable was not from the command line. Ignore it,
23131       # but warn the user (except for BASH, which is always set by the calling BASH).
23132       if test "xCODESIGN" != xBASH; then
23133         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
23134 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
23135       fi
23136       # Try to locate tool using the code snippet
23137       for ac_prog in codesign
23138 do
23139   # Extract the first word of "$ac_prog", so it can be a program name with args.
23140 set dummy $ac_prog; ac_word=$2
23141 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23142 $as_echo_n "checking for $ac_word... " >&6; }
23143 if ${ac_cv_path_CODESIGN+:} false; then :
23144   $as_echo_n "(cached) " >&6
23145 else
23146   case $CODESIGN in
23147   [\\/]* | ?:[\\/]*)
23148   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23149   ;;
23150   *)
23151   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23152 for as_dir in $PATH
23153 do
23154   IFS=$as_save_IFS
23155   test -z "$as_dir" && as_dir=.
23156     for ac_exec_ext in '' $ac_executable_extensions; do
23157   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23158     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23159     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23160     break 2
23161   fi
23162 done
23163   done
23164 IFS=$as_save_IFS
23165 
23166   ;;
23167 esac
23168 fi
23169 CODESIGN=$ac_cv_path_CODESIGN
23170 if test -n "$CODESIGN"; then
23171   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23172 $as_echo "$CODESIGN" >&6; }
23173 else
23174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23175 $as_echo "no" >&6; }
23176 fi
23177 
23178 
23179   test -n "$CODESIGN" && break
23180 done
23181 
23182     else
23183       # If it succeeded, then it was overridden by the user. We will use it
23184       # for the tool.
23185 
23186       # First remove it from the list of overridden variables, so we can test
23187       # for unknown variables in the end.
23188       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23189 
23190       # Check if we try to supply an empty value
23191       if test "x$CODESIGN" = x; then
23192         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
23193 $as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
23194         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23195 $as_echo_n "checking for CODESIGN... " >&6; }
23196         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23197 $as_echo "disabled" >&6; }
23198       else
23199         # Check if the provided tool contains a complete path.
23200         tool_specified="$CODESIGN"
23201         tool_basename="${tool_specified##*/}"
23202         if test "x$tool_basename" = "x$tool_specified"; then
23203           # A command without a complete path is provided, search $PATH.
23204           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
23205 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
23206           # Extract the first word of "$tool_basename", so it can be a program name with args.
23207 set dummy $tool_basename; ac_word=$2
23208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23209 $as_echo_n "checking for $ac_word... " >&6; }
23210 if ${ac_cv_path_CODESIGN+:} false; then :
23211   $as_echo_n "(cached) " >&6
23212 else
23213   case $CODESIGN in
23214   [\\/]* | ?:[\\/]*)
23215   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
23216   ;;
23217   *)
23218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23219 for as_dir in $PATH
23220 do
23221   IFS=$as_save_IFS
23222   test -z "$as_dir" && as_dir=.
23223     for ac_exec_ext in '' $ac_executable_extensions; do
23224   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23225     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
23226     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23227     break 2
23228   fi
23229 done
23230   done
23231 IFS=$as_save_IFS
23232 
23233   ;;
23234 esac
23235 fi
23236 CODESIGN=$ac_cv_path_CODESIGN
23237 if test -n "$CODESIGN"; then
23238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
23239 $as_echo "$CODESIGN" >&6; }
23240 else
23241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23242 $as_echo "no" >&6; }
23243 fi
23244 
23245 
23246           if test "x$CODESIGN" = x; then
23247             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23248           fi
23249         else
23250           # Otherwise we believe it is a complete path. Use it as it is.
23251           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
23252 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
23253           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
23254 $as_echo_n "checking for CODESIGN... " >&6; }
23255           if test ! -x "$tool_specified"; then
23256             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23257 $as_echo "not found" >&6; }
23258             as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
23259           fi
23260           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23261 $as_echo "$tool_specified" >&6; }
23262         fi
23263       fi
23264     fi
23265 
23266   fi
23267 
23268 
23269     if test "x$CODESIGN" != "x"; then
23270       # Verify that the openjdk_codesign certificate is present
23271       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
23272 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
23273       rm -f codesign-testfile
23274       touch codesign-testfile
23275       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
23276       rm -f codesign-testfile
23277       if test "x$CODESIGN" = x; then
23278         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23279 $as_echo "no" >&6; }
23280       else
23281         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23282 $as_echo "yes" >&6; }
23283       fi
23284     fi
23285 
23286 
23287 
23288   # Publish this variable in the help.
23289 
23290 
23291   if [ -z "${SETFILE+x}" ]; then
23292     # The variable is not set by user, try to locate tool using the code snippet
23293     for ac_prog in SetFile
23294 do
23295   # Extract the first word of "$ac_prog", so it can be a program name with args.
23296 set dummy $ac_prog; ac_word=$2
23297 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23298 $as_echo_n "checking for $ac_word... " >&6; }
23299 if ${ac_cv_path_SETFILE+:} false; then :
23300   $as_echo_n "(cached) " >&6
23301 else
23302   case $SETFILE in
23303   [\\/]* | ?:[\\/]*)
23304   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23305   ;;
23306   *)
23307   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23308 for as_dir in $PATH
23309 do
23310   IFS=$as_save_IFS
23311   test -z "$as_dir" && as_dir=.
23312     for ac_exec_ext in '' $ac_executable_extensions; do
23313   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23314     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23315     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23316     break 2
23317   fi
23318 done
23319   done
23320 IFS=$as_save_IFS
23321 
23322   ;;
23323 esac
23324 fi
23325 SETFILE=$ac_cv_path_SETFILE
23326 if test -n "$SETFILE"; then
23327   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23328 $as_echo "$SETFILE" >&6; }
23329 else
23330   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23331 $as_echo "no" >&6; }
23332 fi
23333 
23334 
23335   test -n "$SETFILE" && break
23336 done
23337 
23338   else
23339     # The variable is set, but is it from the command line or the environment?
23340 
23341     # Try to remove the string !SETFILE! from our list.
23342     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
23343     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
23344       # If it failed, the variable was not from the command line. Ignore it,
23345       # but warn the user (except for BASH, which is always set by the calling BASH).
23346       if test "xSETFILE" != xBASH; then
23347         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
23348 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
23349       fi
23350       # Try to locate tool using the code snippet
23351       for ac_prog in SetFile
23352 do
23353   # Extract the first word of "$ac_prog", so it can be a program name with args.
23354 set dummy $ac_prog; ac_word=$2
23355 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23356 $as_echo_n "checking for $ac_word... " >&6; }
23357 if ${ac_cv_path_SETFILE+:} false; then :
23358   $as_echo_n "(cached) " >&6
23359 else
23360   case $SETFILE in
23361   [\\/]* | ?:[\\/]*)
23362   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23363   ;;
23364   *)
23365   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23366 for as_dir in $PATH
23367 do
23368   IFS=$as_save_IFS
23369   test -z "$as_dir" && as_dir=.
23370     for ac_exec_ext in '' $ac_executable_extensions; do
23371   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23372     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23373     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23374     break 2
23375   fi
23376 done
23377   done
23378 IFS=$as_save_IFS
23379 
23380   ;;
23381 esac
23382 fi
23383 SETFILE=$ac_cv_path_SETFILE
23384 if test -n "$SETFILE"; then
23385   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23386 $as_echo "$SETFILE" >&6; }
23387 else
23388   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23389 $as_echo "no" >&6; }
23390 fi
23391 
23392 
23393   test -n "$SETFILE" && break
23394 done
23395 
23396     else
23397       # If it succeeded, then it was overridden by the user. We will use it
23398       # for the tool.
23399 
23400       # First remove it from the list of overridden variables, so we can test
23401       # for unknown variables in the end.
23402       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
23403 
23404       # Check if we try to supply an empty value
23405       if test "x$SETFILE" = x; then
23406         { $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
23407 $as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
23408         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23409 $as_echo_n "checking for SETFILE... " >&6; }
23410         { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
23411 $as_echo "disabled" >&6; }
23412       else
23413         # Check if the provided tool contains a complete path.
23414         tool_specified="$SETFILE"
23415         tool_basename="${tool_specified##*/}"
23416         if test "x$tool_basename" = "x$tool_specified"; then
23417           # A command without a complete path is provided, search $PATH.
23418           { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
23419 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
23420           # Extract the first word of "$tool_basename", so it can be a program name with args.
23421 set dummy $tool_basename; ac_word=$2
23422 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23423 $as_echo_n "checking for $ac_word... " >&6; }
23424 if ${ac_cv_path_SETFILE+:} false; then :
23425   $as_echo_n "(cached) " >&6
23426 else
23427   case $SETFILE in
23428   [\\/]* | ?:[\\/]*)
23429   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
23430   ;;
23431   *)
23432   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23433 for as_dir in $PATH
23434 do
23435   IFS=$as_save_IFS
23436   test -z "$as_dir" && as_dir=.
23437     for ac_exec_ext in '' $ac_executable_extensions; do
23438   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23439     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
23440     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23441     break 2
23442   fi
23443 done
23444   done
23445 IFS=$as_save_IFS
23446 
23447   ;;
23448 esac
23449 fi
23450 SETFILE=$ac_cv_path_SETFILE
23451 if test -n "$SETFILE"; then
23452   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
23453 $as_echo "$SETFILE" >&6; }
23454 else
23455   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23456 $as_echo "no" >&6; }
23457 fi
23458 
23459 
23460           if test "x$SETFILE" = x; then
23461             as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
23462           fi
23463         else
23464           # Otherwise we believe it is a complete path. Use it as it is.
23465           { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
23466 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
23467           { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
23468 $as_echo_n "checking for SETFILE... " >&6; }
23469           if test ! -x "$tool_specified"; then
23470             { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
23471 $as_echo "not found" >&6; }
23472             as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
23473           fi
23474           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
23475 $as_echo "$tool_specified" >&6; }
23476         fi
23477       fi
23478     fi
23479 
23480   fi
23481 
23482 
23483 
23484   if test "x$SETFILE" = x; then
23485     as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
23486   fi
23487 
23488 
23489   fi
23490 
23491 
23492   # Test if bash supports pipefail.
23493   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
23494 $as_echo_n "checking if bash supports pipefail... " >&6; }
23495   if ${BASH} -c 'set -o pipefail'; then
23496     BASH_ARGS="$BASH_ARGS -o pipefail"
23497     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23498 $as_echo "yes" >&6; }
23499   else
23500     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23501 $as_echo "no" >&6; }
23502   fi
23503 
23504   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
23505 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
23506   if ${BASH} -e -c 'true'; then
23507     BASH_ARGS="$BASH_ARGS -e"
23508     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23509 $as_echo "yes" >&6; }
23510   else
23511     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23512 $as_echo "no" >&6; }
23513   fi
23514 
23515 
23516 
23517 
23518 # Check if pkg-config is available.
23519 
23520 
23521 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
23522         if test -n "$ac_tool_prefix"; then
23523   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
23524 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
23525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23526 $as_echo_n "checking for $ac_word... " >&6; }
23527 if ${ac_cv_path_PKG_CONFIG+:} false; then :
23528   $as_echo_n "(cached) " >&6
23529 else
23530   case $PKG_CONFIG in
23531   [\\/]* | ?:[\\/]*)
23532   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
23533   ;;
23534   *)
23535   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23536 for as_dir in $PATH
23537 do
23538   IFS=$as_save_IFS
23539   test -z "$as_dir" && as_dir=.
23540     for ac_exec_ext in '' $ac_executable_extensions; do
23541   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23542     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
23543     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23544     break 2
23545   fi
23546 done
23547   done
23548 IFS=$as_save_IFS
23549 
23550   ;;
23551 esac
23552 fi
23553 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
23554 if test -n "$PKG_CONFIG"; then
23555   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
23556 $as_echo "$PKG_CONFIG" >&6; }
23557 else
23558   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23559 $as_echo "no" >&6; }
23560 fi
23561 
23562 
23563 fi
23564 if test -z "$ac_cv_path_PKG_CONFIG"; then
23565   ac_pt_PKG_CONFIG=$PKG_CONFIG
23566   # Extract the first word of "pkg-config", so it can be a program name with args.
23567 set dummy pkg-config; ac_word=$2
23568 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
23569 $as_echo_n "checking for $ac_word... " >&6; }
23570 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
23571   $as_echo_n "(cached) " >&6
23572 else
23573   case $ac_pt_PKG_CONFIG in
23574   [\\/]* | ?:[\\/]*)
23575   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
23576   ;;
23577   *)
23578   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
23579 for as_dir in $PATH
23580 do
23581   IFS=$as_save_IFS
23582   test -z "$as_dir" && as_dir=.
23583     for ac_exec_ext in '' $ac_executable_extensions; do
23584   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
23585     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
23586     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
23587     break 2
23588   fi
23589 done
23590   done
23591 IFS=$as_save_IFS
23592 
23593   ;;
23594 esac
23595 fi
23596 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
23597 if test -n "$ac_pt_PKG_CONFIG"; then
23598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
23599 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
23600 else
23601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23602 $as_echo "no" >&6; }
23603 fi
23604 
23605   if test "x$ac_pt_PKG_CONFIG" = x; then
23606     PKG_CONFIG=""
23607   else
23608     case $cross_compiling:$ac_tool_warned in
23609 yes:)
23610 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
23611 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
23612 ac_tool_warned=yes ;;
23613 esac
23614     PKG_CONFIG=$ac_pt_PKG_CONFIG
23615   fi
23616 else
23617   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
23618 fi
23619 
23620 fi
23621 if test -n "$PKG_CONFIG"; then
23622         _pkg_min_version=0.9.0
23623         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
23624 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
23625         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
23626                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23627 $as_echo "yes" >&6; }
23628         else
23629                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23630 $as_echo "no" >&6; }
23631                 PKG_CONFIG=""
23632         fi
23633 
23634 fi
23635 
23636 # After basic tools have been setup, we can check build os specific details.
23637 
23638   ###############################################################################
23639 
23640   # Note that this is the build platform OS version!
23641 
23642   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
23643   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
23644   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
23645   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
23646 
23647 
23648 
23649 
23650 
23651 # Misc basic settings
23652 
23653 
23654 # Check whether --with-default-make-target was given.
23655 if test "${with_default_make_target+set}" = set; then :
23656   withval=$with_default_make_target;
23657 fi
23658 
23659   if test "x$with_default_make_target" = "x" \
23660       || test "x$with_default_make_target" = "xyes"; then
23661     DEFAULT_MAKE_TARGET="exploded-image"
23662   elif test "x$with_default_make_target" = "xno"; then
23663     as_fn_error $? "--without-default-make-target is not a valid option" "$LINENO" 5
23664   else
23665     DEFAULT_MAKE_TARGET="$with_default_make_target"
23666   fi
23667 
23668 
23669 
23670 
23671 ###############################################################################
23672 #
23673 # Determine OpenJDK variants, options and version numbers.
23674 #
23675 ###############################################################################
23676 
23677 # We need build & target for this.
23678 
23679   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
23680   # We always build headless support.
23681   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
23682 $as_echo_n "checking headful support... " >&6; }
23683   # Check whether --enable-headful was given.
23684 if test "${enable_headful+set}" = set; then :
23685   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
23686 else
23687   SUPPORT_HEADFUL=yes
23688 fi
23689 
23690 
23691   SUPPORT_HEADLESS=yes
23692   BUILD_HEADLESS="BUILD_HEADLESS:=true"
23693 
23694   if test "x$SUPPORT_HEADFUL" = xyes; then
23695     # We are building both headful and headless.
23696     headful_msg="include support for both headful and headless"
23697   fi
23698 
23699   if test "x$SUPPORT_HEADFUL" = xno; then
23700     # Thus we are building headless only.
23701     BUILD_HEADLESS="BUILD_HEADLESS:=true"
23702     headful_msg="headless only"
23703   fi
23704 
23705   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
23706 $as_echo "$headful_msg" >&6; }
23707 
23708 
23709 
23710 
23711 
23712   # Choose cacerts source file
23713 
23714 # Check whether --with-cacerts-file was given.
23715 if test "${with_cacerts_file+set}" = set; then :
23716   withval=$with_cacerts_file;
23717 fi
23718 
23719   if test "x$with_cacerts_file" != x; then
23720     CACERTS_FILE=$with_cacerts_file
23721   fi
23722 
23723 
23724   # Enable or disable unlimited crypto
23725   # Check whether --enable-unlimited-crypto was given.
23726 if test "${enable_unlimited_crypto+set}" = set; then :
23727   enableval=$enable_unlimited_crypto;
23728 else
23729   enable_unlimited_crypto=no
23730 fi
23731 
23732   if test "x$enable_unlimited_crypto" = "xyes"; then
23733     UNLIMITED_CRYPTO=true
23734   else
23735     UNLIMITED_CRYPTO=false
23736   fi
23737 
23738 
23739   # Should we build the serviceability agent (SA)?
23740   INCLUDE_SA=true
23741   if   [[ " $JVM_VARIANTS " =~ " zero " ]]   ||   [[ " $JVM_VARIANTS " =~ " zeroshark " ]]  ; then
23742     INCLUDE_SA=false
23743   fi
23744   if test "x$OPENJDK_TARGET_OS" = xaix ; then
23745     INCLUDE_SA=false
23746   fi
23747   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
23748     INCLUDE_SA=false
23749   fi
23750 
23751 
23752   # Compress jars
23753   COMPRESS_JARS=false
23754 
23755 
23756 
23757   # Setup default copyright year. Mostly overridden when building close to a new year.
23758 
23759 # Check whether --with-copyright-year was given.
23760 if test "${with_copyright_year+set}" = set; then :
23761   withval=$with_copyright_year;
23762 fi
23763 
23764   if test "x$with_copyright_year" = xyes; then
23765     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
23766   elif test "x$with_copyright_year" != x; then
23767     COPYRIGHT_YEAR="$with_copyright_year"
23768   else
23769     COPYRIGHT_YEAR=`date +'%Y'`
23770   fi
23771 
23772 
23773 
23774   # Check whether --enable-keep-packaged-modules was given.
23775 if test "${enable_keep_packaged_modules+set}" = set; then :
23776   enableval=$enable_keep_packaged_modules;
23777 fi
23778 
23779 
23780   if test "x$enable_keep_packaged_modules" = "xyes"; then
23781     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
23782 $as_echo_n "checking if packaged modules are kept... " >&6; }
23783     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
23784 $as_echo "yes" >&6; }
23785     JLINK_KEEP_PACKAGED_MODULES=true
23786   elif test "x$enable_keep_packaged_modules" = "xno"; then
23787     { $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
23788 $as_echo_n "checking if packaged modules are kept... " >&6; }
23789     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
23790 $as_echo "no" >&6; }
23791     JLINK_KEEP_PACKAGED_MODULES=false
23792   elif test "x$enable_keep_packaged_modules" = "x"; then
23793     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
23794 $as_echo "yes (default)" >&6; }
23795     JLINK_KEEP_PACKAGED_MODULES=true
23796   else
23797     as_fn_error $? "--enable-keep-packaged-modules accepts no argument" "$LINENO" 5
23798   fi
23799 
23800 
23801 
23802 
23803   # Warn user that old version arguments are deprecated.
23804 
23805 
23806 # Check whether --with-milestone was given.
23807 if test "${with_milestone+set}" = set; then :
23808   withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
23809 $as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
23810 fi
23811 
23812 
23813 
23814 
23815 # Check whether --with-update-version was given.
23816 if test "${with_update_version+set}" = set; then :
23817   withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
23818 $as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
23819 fi
23820 
23821 
23822 
23823 
23824 # Check whether --with-user-release-suffix was given.
23825 if test "${with_user_release_suffix+set}" = set; then :
23826   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
23827 $as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
23828 fi
23829 
23830 
23831 
23832 
23833 # Check whether --with-build-number was given.
23834 if test "${with_build_number+set}" = set; then :
23835   withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
23836 $as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
23837 fi
23838 
23839 
23840 
23841   # Source the version numbers file
23842   . $AUTOCONF_DIR/version-numbers
23843 
23844   # Some non-version number information is set in that file
23845 
23846 
23847 
23848 
23849 
23850 
23851 
23852 
23853 
23854   # Override version from arguments
23855 
23856   # If --with-version-string is set, process it first. It is possible to
23857   # override parts with more specific flags, since these are processed later.
23858 
23859 # Check whether --with-version-string was given.
23860 if test "${with_version_string+set}" = set; then :
23861   withval=$with_version_string;
23862 fi
23863 
23864   if test "x$with_version_string" = xyes; then
23865     as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
23866   elif test "x$with_version_string" != x; then
23867     # Additional [] needed to keep m4 from mangling shell constructs.
23868     if  [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
23869       VERSION_MAJOR=${BASH_REMATCH[1]}
23870       VERSION_MINOR=${BASH_REMATCH[3]}
23871       VERSION_SECURITY=${BASH_REMATCH[5]}
23872       VERSION_PATCH=${BASH_REMATCH[7]}
23873       VERSION_PRE=${BASH_REMATCH[9]}
23874       version_plus_separator=${BASH_REMATCH[11]}
23875       VERSION_BUILD=${BASH_REMATCH[12]}
23876       VERSION_OPT=${BASH_REMATCH[14]}
23877       # Unspecified numerical fields are interpreted as 0.
23878       if test "x$VERSION_MINOR" = x; then
23879         VERSION_MINOR=0
23880       fi
23881       if test "x$VERSION_SECURITY" = x; then
23882         VERSION_SECURITY=0
23883       fi
23884       if test "x$VERSION_PATCH" = x; then
23885         VERSION_PATCH=0
23886       fi
23887       if test "x$version_plus_separator" != x \
23888           && test "x$VERSION_BUILD$VERSION_OPT" = x; then
23889         as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
23890       fi
23891       # Stop the version part process from setting default values.
23892       # We still allow them to explicitely override though.
23893       NO_DEFAULT_VERSION_PARTS=true
23894     else
23895       as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
23896     fi
23897   fi
23898 
23899 
23900 # Check whether --with-version-pre was given.
23901 if test "${with_version_pre+set}" = set; then :
23902   withval=$with_version_pre; with_version_pre_present=true
23903 else
23904   with_version_pre_present=false
23905 fi
23906 
23907 
23908   if test "x$with_version_pre_present" = xtrue; then
23909     if test "x$with_version_pre" = xyes; then
23910       as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
23911     elif test "x$with_version_pre" = xno; then
23912       # Interpret --without-* as empty string instead of the literal "no"
23913       VERSION_PRE=
23914     else
23915       # Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
23916        VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
23917       if test "x$VERSION_PRE" != "x$with_version_pre"; then
23918         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
23919 $as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
23920       fi
23921     fi
23922   else
23923     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23924       # Default is to use "internal" as pre
23925       VERSION_PRE="internal"
23926     fi
23927   fi
23928 
23929 
23930 # Check whether --with-version-opt was given.
23931 if test "${with_version_opt+set}" = set; then :
23932   withval=$with_version_opt; with_version_opt_present=true
23933 else
23934   with_version_opt_present=false
23935 fi
23936 
23937 
23938   if test "x$with_version_opt_present" = xtrue; then
23939     if test "x$with_version_opt" = xyes; then
23940       as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
23941     elif test "x$with_version_opt" = xno; then
23942       # Interpret --without-* as empty string instead of the literal "no"
23943       VERSION_OPT=
23944     else
23945       # Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
23946        VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
23947       if test "x$VERSION_OPT" != "x$with_version_opt"; then
23948         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
23949 $as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
23950       fi
23951     fi
23952   else
23953     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
23954       # Default is to calculate a string like this <timestamp>.<username>.<base dir name>
23955       timestamp=`$DATE '+%Y-%m-%d-%H%M%S'`
23956       # Outer [ ] to quote m4.
23957        basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
23958       VERSION_OPT="$timestamp.$USERNAME.$basedirname"
23959     fi
23960   fi
23961 
23962 
23963 # Check whether --with-version-build was given.
23964 if test "${with_version_build+set}" = set; then :
23965   withval=$with_version_build; with_version_build_present=true
23966 else
23967   with_version_build_present=false
23968 fi
23969 
23970 
23971   if test "x$with_version_build_present" = xtrue; then
23972     if test "x$with_version_build" = xyes; then
23973       as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
23974     elif test "x$with_version_build" = xno; then
23975       # Interpret --without-* as empty string instead of the literal "no"
23976       VERSION_BUILD=
23977     elif test "x$with_version_build" = x; then
23978       VERSION_BUILD=
23979     else
23980 
23981   # Additional [] needed to keep m4 from mangling shell constructs.
23982   if  ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
23983     as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
23984   fi
23985   # Extract the version number without leading zeros.
23986   cleaned_value=${BASH_REMATCH[1]}
23987   if test "x$cleaned_value" = x; then
23988     # Special case for zero
23989     cleaned_value=${BASH_REMATCH[2]}
23990   fi
23991 
23992   if test $cleaned_value -gt 255; then
23993     as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
23994   fi
23995   if test "x$cleaned_value" != "x$with_version_build"; then
23996     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
23997 $as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
23998   fi
23999   VERSION_BUILD=$cleaned_value
24000 
24001     fi
24002   else
24003     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24004       # Default is to not have a build number.
24005       VERSION_BUILD=""
24006       # FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
24007       VERSION_BUILD=0
24008     fi
24009   fi
24010 
24011 
24012 # Check whether --with-version-major was given.
24013 if test "${with_version_major+set}" = set; then :
24014   withval=$with_version_major; with_version_major_present=true
24015 else
24016   with_version_major_present=false
24017 fi
24018 
24019 
24020   if test "x$with_version_major_present" = xtrue; then
24021     if test "x$with_version_major" = xyes; then
24022       as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
24023     else
24024 
24025   # Additional [] needed to keep m4 from mangling shell constructs.
24026   if  ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24027     as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
24028   fi
24029   # Extract the version number without leading zeros.
24030   cleaned_value=${BASH_REMATCH[1]}
24031   if test "x$cleaned_value" = x; then
24032     # Special case for zero
24033     cleaned_value=${BASH_REMATCH[2]}
24034   fi
24035 
24036   if test $cleaned_value -gt 255; then
24037     as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
24038   fi
24039   if test "x$cleaned_value" != "x$with_version_major"; then
24040     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
24041 $as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
24042   fi
24043   VERSION_MAJOR=$cleaned_value
24044 
24045     fi
24046   else
24047     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24048       # Default is to get value from version-numbers
24049       VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
24050     fi
24051   fi
24052 
24053 
24054 # Check whether --with-version-minor was given.
24055 if test "${with_version_minor+set}" = set; then :
24056   withval=$with_version_minor; with_version_minor_present=true
24057 else
24058   with_version_minor_present=false
24059 fi
24060 
24061 
24062   if test "x$with_version_minor_present" = xtrue; then
24063     if test "x$with_version_minor" = xyes; then
24064       as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
24065     elif test "x$with_version_minor" = xno; then
24066       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24067       VERSION_MINOR=0
24068     elif test "x$with_version_minor" = x; then
24069       VERSION_MINOR=0
24070     else
24071 
24072   # Additional [] needed to keep m4 from mangling shell constructs.
24073   if  ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24074     as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
24075   fi
24076   # Extract the version number without leading zeros.
24077   cleaned_value=${BASH_REMATCH[1]}
24078   if test "x$cleaned_value" = x; then
24079     # Special case for zero
24080     cleaned_value=${BASH_REMATCH[2]}
24081   fi
24082 
24083   if test $cleaned_value -gt 255; then
24084     as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
24085   fi
24086   if test "x$cleaned_value" != "x$with_version_minor"; then
24087     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
24088 $as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
24089   fi
24090   VERSION_MINOR=$cleaned_value
24091 
24092     fi
24093   else
24094     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24095       # Default is 0, if unspecified
24096       VERSION_MINOR=0
24097     fi
24098   fi
24099 
24100 
24101 # Check whether --with-version-security was given.
24102 if test "${with_version_security+set}" = set; then :
24103   withval=$with_version_security; with_version_security_present=true
24104 else
24105   with_version_security_present=false
24106 fi
24107 
24108 
24109   if test "x$with_version_security_present" = xtrue; then
24110     if test "x$with_version_security" = xyes; then
24111       as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
24112     elif test "x$with_version_security" = xno; then
24113       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24114       VERSION_SECURITY=0
24115     elif test "x$with_version_security" = x; then
24116       VERSION_SECURITY=0
24117     else
24118 
24119   # Additional [] needed to keep m4 from mangling shell constructs.
24120   if  ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24121     as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
24122   fi
24123   # Extract the version number without leading zeros.
24124   cleaned_value=${BASH_REMATCH[1]}
24125   if test "x$cleaned_value" = x; then
24126     # Special case for zero
24127     cleaned_value=${BASH_REMATCH[2]}
24128   fi
24129 
24130   if test $cleaned_value -gt 255; then
24131     as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
24132   fi
24133   if test "x$cleaned_value" != "x$with_version_security"; then
24134     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
24135 $as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
24136   fi
24137   VERSION_SECURITY=$cleaned_value
24138 
24139     fi
24140   else
24141     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24142       # Default is 0, if unspecified
24143       VERSION_SECURITY=0
24144     fi
24145   fi
24146 
24147 
24148 # Check whether --with-version-patch was given.
24149 if test "${with_version_patch+set}" = set; then :
24150   withval=$with_version_patch; with_version_patch_present=true
24151 else
24152   with_version_patch_present=false
24153 fi
24154 
24155 
24156   if test "x$with_version_patch_present" = xtrue; then
24157     if test "x$with_version_patch" = xyes; then
24158       as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
24159     elif test "x$with_version_patch" = xno; then
24160       # Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
24161       VERSION_PATCH=0
24162     elif test "x$with_version_patch" = x; then
24163       VERSION_PATCH=0
24164     else
24165 
24166   # Additional [] needed to keep m4 from mangling shell constructs.
24167   if  ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]]  ; then
24168     as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
24169   fi
24170   # Extract the version number without leading zeros.
24171   cleaned_value=${BASH_REMATCH[1]}
24172   if test "x$cleaned_value" = x; then
24173     # Special case for zero
24174     cleaned_value=${BASH_REMATCH[2]}
24175   fi
24176 
24177   if test $cleaned_value -gt 255; then
24178     as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
24179   fi
24180   if test "x$cleaned_value" != "x$with_version_patch"; then
24181     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
24182 $as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
24183   fi
24184   VERSION_PATCH=$cleaned_value
24185 
24186     fi
24187   else
24188     if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
24189       # Default is 0, if unspecified
24190       VERSION_PATCH=0
24191     fi
24192   fi
24193 
24194   # Calculate derived version properties
24195 
24196   # Set VERSION_IS_GA based on if VERSION_PRE has a value
24197   if test "x$VERSION_PRE" = x; then
24198     VERSION_IS_GA=true
24199   else
24200     VERSION_IS_GA=false
24201   fi
24202 
24203   # VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
24204   VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
24205 
24206   stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
24207   # Strip trailing zeroes from stripped_version_number
24208   for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
24209   VERSION_NUMBER=$stripped_version_number
24210 
24211   # The complete version string, with additional build information
24212   if test "x$VERSION_BUILD$VERSION_OPT" = x; then
24213     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24214   else
24215     # If either build or opt is set, we need a + separator
24216     VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
24217   fi
24218 
24219   # The short version string, just VERSION_NUMBER and PRE, if present.
24220   VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
24221 
24222   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
24223 $as_echo_n "checking for version string... " >&6; }
24224   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
24225 $as_echo "$VERSION_STRING" >&6; }
24226 
24227 
24228 
24229 
24230 
24231 
24232 
24233 
24234 
24235 
24236 
24237 
24238 
24239 
24240 
24241 ###############################################################################
24242 #
24243 # Setup BootJDK, used to bootstrap the build.
24244 #
24245 ###############################################################################
24246 
24247 
24248   BOOT_JDK_FOUND=no
24249 
24250 # Check whether --with-boot-jdk was given.
24251 if test "${with_boot_jdk+set}" = set; then :
24252   withval=$with_boot_jdk;
24253 fi
24254 
24255 
24256   # We look for the Boot JDK through various means, going from more certain to
24257   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
24258   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
24259   # must check if this is indeed valid; otherwise we'll continue looking.
24260 
24261   # Test: Is bootjdk explicitely set by command line arguments?
24262 
24263   if test "x$BOOT_JDK_FOUND" = xno; then
24264     # Now execute the test
24265 
24266   if test "x$with_boot_jdk" != x; then
24267     BOOT_JDK=$with_boot_jdk
24268     BOOT_JDK_FOUND=maybe
24269     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
24270 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
24271   fi
24272 
24273 
24274     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24275     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24276       # Do we have a bin/java?
24277       if test ! -x "$BOOT_JDK/bin/java"; then
24278         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24279 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24280         BOOT_JDK_FOUND=no
24281       else
24282         # Do we have a bin/javac?
24283         if test ! -x "$BOOT_JDK/bin/javac"; then
24284           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24285 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24286           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24287 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24288           BOOT_JDK_FOUND=no
24289         else
24290           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24291           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24292 
24293           # Extra M4 quote needed to protect [] in grep expression.
24294           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24295           if test "x$FOUND_CORRECT_VERSION" = x; then
24296             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24297 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24298             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24299 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24300             BOOT_JDK_FOUND=no
24301           else
24302             # We're done! :-)
24303             BOOT_JDK_FOUND=yes
24304 
24305   # Only process if variable expands to non-empty
24306 
24307   if test "x$BOOT_JDK" != x; then
24308     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24309 
24310   # Input might be given as Windows format, start by converting to
24311   # unix format.
24312   path="$BOOT_JDK"
24313   new_path=`$CYGPATH -u "$path"`
24314 
24315   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24316   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24317   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24318   # "foo.exe" is OK but "foo" is an error.
24319   #
24320   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24321   # It is also a way to make sure we got the proper file name for the real test later on.
24322   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24323   if test "x$test_shortpath" = x; then
24324     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24325 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24326     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24327   fi
24328 
24329   # Call helper function which possibly converts this using DOS-style short mode.
24330   # If so, the updated path is stored in $new_path.
24331 
24332   input_path="$new_path"
24333   # Check if we need to convert this using DOS-style short mode. If the path
24334   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24335   # take no chances and rewrite it.
24336   # Note: m4 eats our [], so we need to use [ and ] instead.
24337   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24338   if test "x$has_forbidden_chars" != x; then
24339     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24340     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24341     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24342     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24343       # Going to short mode and back again did indeed matter. Since short mode is
24344       # case insensitive, let's make it lowercase to improve readability.
24345       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24346       # Now convert it back to Unix-style (cygpath)
24347       input_path=`$CYGPATH -u "$shortmode_path"`
24348       new_path="$input_path"
24349     fi
24350   fi
24351 
24352   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24353   if test "x$test_cygdrive_prefix" = x; then
24354     # As a simple fix, exclude /usr/bin since it's not a real path.
24355     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24356       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24357       # a path prefixed by /cygdrive for fixpath to work.
24358       new_path="$CYGWIN_ROOT_PATH$input_path"
24359     fi
24360   fi
24361 
24362 
24363   if test "x$path" != "x$new_path"; then
24364     BOOT_JDK="$new_path"
24365     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24366 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24367   fi
24368 
24369     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24370 
24371   path="$BOOT_JDK"
24372   has_colon=`$ECHO $path | $GREP ^.:`
24373   new_path="$path"
24374   if test "x$has_colon" = x; then
24375     # Not in mixed or Windows style, start by that.
24376     new_path=`cmd //c echo $path`
24377   fi
24378 
24379 
24380   input_path="$new_path"
24381   # Check if we need to convert this using DOS-style short mode. If the path
24382   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24383   # take no chances and rewrite it.
24384   # Note: m4 eats our [], so we need to use [ and ] instead.
24385   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24386   if test "x$has_forbidden_chars" != x; then
24387     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24388     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24389   fi
24390 
24391 
24392   windows_path="$new_path"
24393   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24394     unix_path=`$CYGPATH -u "$windows_path"`
24395     new_path="$unix_path"
24396   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24397     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24398     new_path="$unix_path"
24399   fi
24400 
24401   if test "x$path" != "x$new_path"; then
24402     BOOT_JDK="$new_path"
24403     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24404 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24405   fi
24406 
24407   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24408   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24409 
24410     else
24411       # We're on a unix platform. Hooray! :)
24412       path="$BOOT_JDK"
24413       has_space=`$ECHO "$path" | $GREP " "`
24414       if test "x$has_space" != x; then
24415         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24416 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24417         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24418       fi
24419 
24420       # Use eval to expand a potential ~
24421       eval path="$path"
24422       if test ! -f "$path" && test ! -d "$path"; then
24423         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24424       fi
24425 
24426       if test -d "$path"; then
24427         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24428       else
24429         dir="`$DIRNAME "$path"`"
24430         base="`$BASENAME "$path"`"
24431         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24432       fi
24433     fi
24434   fi
24435 
24436             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24437 $as_echo_n "checking for Boot JDK... " >&6; }
24438             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24439 $as_echo "$BOOT_JDK" >&6; }
24440             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24441 $as_echo_n "checking Boot JDK version... " >&6; }
24442             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24443             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24444 $as_echo "$BOOT_JDK_VERSION" >&6; }
24445           fi # end check jdk version
24446         fi # end check javac
24447       fi # end check java
24448     fi # end check boot jdk found
24449   fi
24450 
24451   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
24452     # Having specified an argument which is incorrect will produce an instant failure;
24453     # we should not go on looking
24454     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
24455   fi
24456 
24457   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
24458 
24459   if test "x$BOOT_JDK_FOUND" = xno; then
24460     # Now execute the test
24461 
24462   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
24463     # First check at user selected default
24464 
24465   if test "x$BOOT_JDK_FOUND" = xno; then
24466     # Now execute the test
24467 
24468   if test -x /usr/libexec/java_home; then
24469     BOOT_JDK=`/usr/libexec/java_home `
24470     BOOT_JDK_FOUND=maybe
24471     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
24472 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
24473   fi
24474 
24475 
24476     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24477     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24478       # Do we have a bin/java?
24479       if test ! -x "$BOOT_JDK/bin/java"; then
24480         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24481 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24482         BOOT_JDK_FOUND=no
24483       else
24484         # Do we have a bin/javac?
24485         if test ! -x "$BOOT_JDK/bin/javac"; then
24486           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24487 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24488           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24489 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24490           BOOT_JDK_FOUND=no
24491         else
24492           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24493           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24494 
24495           # Extra M4 quote needed to protect [] in grep expression.
24496           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24497           if test "x$FOUND_CORRECT_VERSION" = x; then
24498             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24499 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24500             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24501 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24502             BOOT_JDK_FOUND=no
24503           else
24504             # We're done! :-)
24505             BOOT_JDK_FOUND=yes
24506 
24507   # Only process if variable expands to non-empty
24508 
24509   if test "x$BOOT_JDK" != x; then
24510     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24511 
24512   # Input might be given as Windows format, start by converting to
24513   # unix format.
24514   path="$BOOT_JDK"
24515   new_path=`$CYGPATH -u "$path"`
24516 
24517   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24518   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24519   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24520   # "foo.exe" is OK but "foo" is an error.
24521   #
24522   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24523   # It is also a way to make sure we got the proper file name for the real test later on.
24524   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24525   if test "x$test_shortpath" = x; then
24526     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24527 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24528     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24529   fi
24530 
24531   # Call helper function which possibly converts this using DOS-style short mode.
24532   # If so, the updated path is stored in $new_path.
24533 
24534   input_path="$new_path"
24535   # Check if we need to convert this using DOS-style short mode. If the path
24536   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24537   # take no chances and rewrite it.
24538   # Note: m4 eats our [], so we need to use [ and ] instead.
24539   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24540   if test "x$has_forbidden_chars" != x; then
24541     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24542     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24543     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24544     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24545       # Going to short mode and back again did indeed matter. Since short mode is
24546       # case insensitive, let's make it lowercase to improve readability.
24547       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24548       # Now convert it back to Unix-style (cygpath)
24549       input_path=`$CYGPATH -u "$shortmode_path"`
24550       new_path="$input_path"
24551     fi
24552   fi
24553 
24554   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24555   if test "x$test_cygdrive_prefix" = x; then
24556     # As a simple fix, exclude /usr/bin since it's not a real path.
24557     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24558       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24559       # a path prefixed by /cygdrive for fixpath to work.
24560       new_path="$CYGWIN_ROOT_PATH$input_path"
24561     fi
24562   fi
24563 
24564 
24565   if test "x$path" != "x$new_path"; then
24566     BOOT_JDK="$new_path"
24567     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24568 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24569   fi
24570 
24571     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24572 
24573   path="$BOOT_JDK"
24574   has_colon=`$ECHO $path | $GREP ^.:`
24575   new_path="$path"
24576   if test "x$has_colon" = x; then
24577     # Not in mixed or Windows style, start by that.
24578     new_path=`cmd //c echo $path`
24579   fi
24580 
24581 
24582   input_path="$new_path"
24583   # Check if we need to convert this using DOS-style short mode. If the path
24584   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24585   # take no chances and rewrite it.
24586   # Note: m4 eats our [], so we need to use [ and ] instead.
24587   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24588   if test "x$has_forbidden_chars" != x; then
24589     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24590     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24591   fi
24592 
24593 
24594   windows_path="$new_path"
24595   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24596     unix_path=`$CYGPATH -u "$windows_path"`
24597     new_path="$unix_path"
24598   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24599     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24600     new_path="$unix_path"
24601   fi
24602 
24603   if test "x$path" != "x$new_path"; then
24604     BOOT_JDK="$new_path"
24605     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24606 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24607   fi
24608 
24609   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24610   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24611 
24612     else
24613       # We're on a unix platform. Hooray! :)
24614       path="$BOOT_JDK"
24615       has_space=`$ECHO "$path" | $GREP " "`
24616       if test "x$has_space" != x; then
24617         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24618 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24619         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24620       fi
24621 
24622       # Use eval to expand a potential ~
24623       eval path="$path"
24624       if test ! -f "$path" && test ! -d "$path"; then
24625         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24626       fi
24627 
24628       if test -d "$path"; then
24629         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24630       else
24631         dir="`$DIRNAME "$path"`"
24632         base="`$BASENAME "$path"`"
24633         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24634       fi
24635     fi
24636   fi
24637 
24638             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24639 $as_echo_n "checking for Boot JDK... " >&6; }
24640             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24641 $as_echo "$BOOT_JDK" >&6; }
24642             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24643 $as_echo_n "checking Boot JDK version... " >&6; }
24644             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24645             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24646 $as_echo "$BOOT_JDK_VERSION" >&6; }
24647           fi # end check jdk version
24648         fi # end check javac
24649       fi # end check java
24650     fi # end check boot jdk found
24651   fi
24652 
24653     # If that did not work out (e.g. too old), try explicit versions instead
24654 
24655   if test "x$BOOT_JDK_FOUND" = xno; then
24656     # Now execute the test
24657 
24658   if test -x /usr/libexec/java_home; then
24659     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
24660     BOOT_JDK_FOUND=maybe
24661     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
24662 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
24663   fi
24664 
24665 
24666     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24667     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24668       # Do we have a bin/java?
24669       if test ! -x "$BOOT_JDK/bin/java"; then
24670         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24671 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24672         BOOT_JDK_FOUND=no
24673       else
24674         # Do we have a bin/javac?
24675         if test ! -x "$BOOT_JDK/bin/javac"; then
24676           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24677 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24678           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24679 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24680           BOOT_JDK_FOUND=no
24681         else
24682           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24683           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24684 
24685           # Extra M4 quote needed to protect [] in grep expression.
24686           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24687           if test "x$FOUND_CORRECT_VERSION" = x; then
24688             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24689 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24690             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24691 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24692             BOOT_JDK_FOUND=no
24693           else
24694             # We're done! :-)
24695             BOOT_JDK_FOUND=yes
24696 
24697   # Only process if variable expands to non-empty
24698 
24699   if test "x$BOOT_JDK" != x; then
24700     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24701 
24702   # Input might be given as Windows format, start by converting to
24703   # unix format.
24704   path="$BOOT_JDK"
24705   new_path=`$CYGPATH -u "$path"`
24706 
24707   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24708   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24709   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24710   # "foo.exe" is OK but "foo" is an error.
24711   #
24712   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24713   # It is also a way to make sure we got the proper file name for the real test later on.
24714   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24715   if test "x$test_shortpath" = x; then
24716     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24717 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24718     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24719   fi
24720 
24721   # Call helper function which possibly converts this using DOS-style short mode.
24722   # If so, the updated path is stored in $new_path.
24723 
24724   input_path="$new_path"
24725   # Check if we need to convert this using DOS-style short mode. If the path
24726   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24727   # take no chances and rewrite it.
24728   # Note: m4 eats our [], so we need to use [ and ] instead.
24729   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24730   if test "x$has_forbidden_chars" != x; then
24731     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24732     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24733     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24734     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24735       # Going to short mode and back again did indeed matter. Since short mode is
24736       # case insensitive, let's make it lowercase to improve readability.
24737       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24738       # Now convert it back to Unix-style (cygpath)
24739       input_path=`$CYGPATH -u "$shortmode_path"`
24740       new_path="$input_path"
24741     fi
24742   fi
24743 
24744   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24745   if test "x$test_cygdrive_prefix" = x; then
24746     # As a simple fix, exclude /usr/bin since it's not a real path.
24747     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24748       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24749       # a path prefixed by /cygdrive for fixpath to work.
24750       new_path="$CYGWIN_ROOT_PATH$input_path"
24751     fi
24752   fi
24753 
24754 
24755   if test "x$path" != "x$new_path"; then
24756     BOOT_JDK="$new_path"
24757     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24758 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24759   fi
24760 
24761     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24762 
24763   path="$BOOT_JDK"
24764   has_colon=`$ECHO $path | $GREP ^.:`
24765   new_path="$path"
24766   if test "x$has_colon" = x; then
24767     # Not in mixed or Windows style, start by that.
24768     new_path=`cmd //c echo $path`
24769   fi
24770 
24771 
24772   input_path="$new_path"
24773   # Check if we need to convert this using DOS-style short mode. If the path
24774   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24775   # take no chances and rewrite it.
24776   # Note: m4 eats our [], so we need to use [ and ] instead.
24777   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24778   if test "x$has_forbidden_chars" != x; then
24779     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24780     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24781   fi
24782 
24783 
24784   windows_path="$new_path"
24785   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24786     unix_path=`$CYGPATH -u "$windows_path"`
24787     new_path="$unix_path"
24788   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24789     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24790     new_path="$unix_path"
24791   fi
24792 
24793   if test "x$path" != "x$new_path"; then
24794     BOOT_JDK="$new_path"
24795     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24796 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24797   fi
24798 
24799   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24800   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24801 
24802     else
24803       # We're on a unix platform. Hooray! :)
24804       path="$BOOT_JDK"
24805       has_space=`$ECHO "$path" | $GREP " "`
24806       if test "x$has_space" != x; then
24807         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24808 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24809         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24810       fi
24811 
24812       # Use eval to expand a potential ~
24813       eval path="$path"
24814       if test ! -f "$path" && test ! -d "$path"; then
24815         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24816       fi
24817 
24818       if test -d "$path"; then
24819         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24820       else
24821         dir="`$DIRNAME "$path"`"
24822         base="`$BASENAME "$path"`"
24823         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
24824       fi
24825     fi
24826   fi
24827 
24828             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24829 $as_echo_n "checking for Boot JDK... " >&6; }
24830             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24831 $as_echo "$BOOT_JDK" >&6; }
24832             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24833 $as_echo_n "checking Boot JDK version... " >&6; }
24834             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24835             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24836 $as_echo "$BOOT_JDK_VERSION" >&6; }
24837           fi # end check jdk version
24838         fi # end check javac
24839       fi # end check java
24840     fi # end check boot jdk found
24841   fi
24842 
24843 
24844   if test "x$BOOT_JDK_FOUND" = xno; then
24845     # Now execute the test
24846 
24847   if test -x /usr/libexec/java_home; then
24848     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
24849     BOOT_JDK_FOUND=maybe
24850     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
24851 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
24852   fi
24853 
24854 
24855     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24856     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24857       # Do we have a bin/java?
24858       if test ! -x "$BOOT_JDK/bin/java"; then
24859         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24860 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24861         BOOT_JDK_FOUND=no
24862       else
24863         # Do we have a bin/javac?
24864         if test ! -x "$BOOT_JDK/bin/javac"; then
24865           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24866 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24867           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24868 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24869           BOOT_JDK_FOUND=no
24870         else
24871           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24872           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24873 
24874           # Extra M4 quote needed to protect [] in grep expression.
24875           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
24876           if test "x$FOUND_CORRECT_VERSION" = x; then
24877             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24878 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24879             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24880 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24881             BOOT_JDK_FOUND=no
24882           else
24883             # We're done! :-)
24884             BOOT_JDK_FOUND=yes
24885 
24886   # Only process if variable expands to non-empty
24887 
24888   if test "x$BOOT_JDK" != x; then
24889     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24890 
24891   # Input might be given as Windows format, start by converting to
24892   # unix format.
24893   path="$BOOT_JDK"
24894   new_path=`$CYGPATH -u "$path"`
24895 
24896   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24897   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24898   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24899   # "foo.exe" is OK but "foo" is an error.
24900   #
24901   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24902   # It is also a way to make sure we got the proper file name for the real test later on.
24903   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24904   if test "x$test_shortpath" = x; then
24905     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24906 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24907     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24908   fi
24909 
24910   # Call helper function which possibly converts this using DOS-style short mode.
24911   # If so, the updated path is stored in $new_path.
24912 
24913   input_path="$new_path"
24914   # Check if we need to convert this using DOS-style short mode. If the path
24915   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24916   # take no chances and rewrite it.
24917   # Note: m4 eats our [], so we need to use [ and ] instead.
24918   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24919   if test "x$has_forbidden_chars" != x; then
24920     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24921     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24922     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24923     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24924       # Going to short mode and back again did indeed matter. Since short mode is
24925       # case insensitive, let's make it lowercase to improve readability.
24926       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24927       # Now convert it back to Unix-style (cygpath)
24928       input_path=`$CYGPATH -u "$shortmode_path"`
24929       new_path="$input_path"
24930     fi
24931   fi
24932 
24933   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24934   if test "x$test_cygdrive_prefix" = x; then
24935     # As a simple fix, exclude /usr/bin since it's not a real path.
24936     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24937       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24938       # a path prefixed by /cygdrive for fixpath to work.
24939       new_path="$CYGWIN_ROOT_PATH$input_path"
24940     fi
24941   fi
24942 
24943 
24944   if test "x$path" != "x$new_path"; then
24945     BOOT_JDK="$new_path"
24946     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24947 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24948   fi
24949 
24950     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24951 
24952   path="$BOOT_JDK"
24953   has_colon=`$ECHO $path | $GREP ^.:`
24954   new_path="$path"
24955   if test "x$has_colon" = x; then
24956     # Not in mixed or Windows style, start by that.
24957     new_path=`cmd //c echo $path`
24958   fi
24959 
24960 
24961   input_path="$new_path"
24962   # Check if we need to convert this using DOS-style short mode. If the path
24963   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24964   # take no chances and rewrite it.
24965   # Note: m4 eats our [], so we need to use [ and ] instead.
24966   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24967   if test "x$has_forbidden_chars" != x; then
24968     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24969     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24970   fi
24971 
24972 
24973   windows_path="$new_path"
24974   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24975     unix_path=`$CYGPATH -u "$windows_path"`
24976     new_path="$unix_path"
24977   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24978     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24979     new_path="$unix_path"
24980   fi
24981 
24982   if test "x$path" != "x$new_path"; then
24983     BOOT_JDK="$new_path"
24984     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24985 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24986   fi
24987 
24988   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24989   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24990 
24991     else
24992       # We're on a unix platform. Hooray! :)
24993       path="$BOOT_JDK"
24994       has_space=`$ECHO "$path" | $GREP " "`
24995       if test "x$has_space" != x; then
24996         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24997 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24998         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24999       fi
25000 
25001       # Use eval to expand a potential ~
25002       eval path="$path"
25003       if test ! -f "$path" && test ! -d "$path"; then
25004         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25005       fi
25006 
25007       if test -d "$path"; then
25008         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25009       else
25010         dir="`$DIRNAME "$path"`"
25011         base="`$BASENAME "$path"`"
25012         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25013       fi
25014     fi
25015   fi
25016 
25017             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25018 $as_echo_n "checking for Boot JDK... " >&6; }
25019             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25020 $as_echo "$BOOT_JDK" >&6; }
25021             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25022 $as_echo_n "checking Boot JDK version... " >&6; }
25023             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25024             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25025 $as_echo "$BOOT_JDK_VERSION" >&6; }
25026           fi # end check jdk version
25027         fi # end check javac
25028       fi # end check java
25029     fi # end check boot jdk found
25030   fi
25031 
25032 
25033   if test "x$BOOT_JDK_FOUND" = xno; then
25034     # Now execute the test
25035 
25036   if test -x /usr/libexec/java_home; then
25037     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
25038     BOOT_JDK_FOUND=maybe
25039     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
25040 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
25041   fi
25042 
25043 
25044     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25045     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25046       # Do we have a bin/java?
25047       if test ! -x "$BOOT_JDK/bin/java"; then
25048         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25049 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25050         BOOT_JDK_FOUND=no
25051       else
25052         # Do we have a bin/javac?
25053         if test ! -x "$BOOT_JDK/bin/javac"; then
25054           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25055 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25056           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25057 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25058           BOOT_JDK_FOUND=no
25059         else
25060           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25061           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
25062 
25063           # Extra M4 quote needed to protect [] in grep expression.
25064           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25065           if test "x$FOUND_CORRECT_VERSION" = x; then
25066             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
25067 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
25068             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
25069 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
25070             BOOT_JDK_FOUND=no
25071           else
25072             # We're done! :-)
25073             BOOT_JDK_FOUND=yes
25074 
25075   # Only process if variable expands to non-empty
25076 
25077   if test "x$BOOT_JDK" != x; then
25078     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25079 
25080   # Input might be given as Windows format, start by converting to
25081   # unix format.
25082   path="$BOOT_JDK"
25083   new_path=`$CYGPATH -u "$path"`
25084 
25085   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
25086   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
25087   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
25088   # "foo.exe" is OK but "foo" is an error.
25089   #
25090   # This test is therefore slightly more accurate than "test -f" to check for file precense.
25091   # It is also a way to make sure we got the proper file name for the real test later on.
25092   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
25093   if test "x$test_shortpath" = x; then
25094     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25095 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25096     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
25097   fi
25098 
25099   # Call helper function which possibly converts this using DOS-style short mode.
25100   # If so, the updated path is stored in $new_path.
25101 
25102   input_path="$new_path"
25103   # Check if we need to convert this using DOS-style short mode. If the path
25104   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25105   # take no chances and rewrite it.
25106   # Note: m4 eats our [], so we need to use [ and ] instead.
25107   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25108   if test "x$has_forbidden_chars" != x; then
25109     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25110     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25111     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25112     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25113       # Going to short mode and back again did indeed matter. Since short mode is
25114       # case insensitive, let's make it lowercase to improve readability.
25115       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25116       # Now convert it back to Unix-style (cygpath)
25117       input_path=`$CYGPATH -u "$shortmode_path"`
25118       new_path="$input_path"
25119     fi
25120   fi
25121 
25122   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25123   if test "x$test_cygdrive_prefix" = x; then
25124     # As a simple fix, exclude /usr/bin since it's not a real path.
25125     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
25126       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25127       # a path prefixed by /cygdrive for fixpath to work.
25128       new_path="$CYGWIN_ROOT_PATH$input_path"
25129     fi
25130   fi
25131 
25132 
25133   if test "x$path" != "x$new_path"; then
25134     BOOT_JDK="$new_path"
25135     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25136 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25137   fi
25138 
25139     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25140 
25141   path="$BOOT_JDK"
25142   has_colon=`$ECHO $path | $GREP ^.:`
25143   new_path="$path"
25144   if test "x$has_colon" = x; then
25145     # Not in mixed or Windows style, start by that.
25146     new_path=`cmd //c echo $path`
25147   fi
25148 
25149 
25150   input_path="$new_path"
25151   # Check if we need to convert this using DOS-style short mode. If the path
25152   # contains just simple characters, use it. Otherwise (spaces, weird characters),
25153   # take no chances and rewrite it.
25154   # Note: m4 eats our [], so we need to use [ and ] instead.
25155   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
25156   if test "x$has_forbidden_chars" != x; then
25157     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25158     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25159   fi
25160 
25161 
25162   windows_path="$new_path"
25163   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25164     unix_path=`$CYGPATH -u "$windows_path"`
25165     new_path="$unix_path"
25166   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25167     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25168     new_path="$unix_path"
25169   fi
25170 
25171   if test "x$path" != "x$new_path"; then
25172     BOOT_JDK="$new_path"
25173     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25174 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25175   fi
25176 
25177   # Save the first 10 bytes of this path to the storage, so fixpath can work.
25178   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25179 
25180     else
25181       # We're on a unix platform. Hooray! :)
25182       path="$BOOT_JDK"
25183       has_space=`$ECHO "$path" | $GREP " "`
25184       if test "x$has_space" != x; then
25185         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25186 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25187         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25188       fi
25189 
25190       # Use eval to expand a potential ~
25191       eval path="$path"
25192       if test ! -f "$path" && test ! -d "$path"; then
25193         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25194       fi
25195 
25196       if test -d "$path"; then
25197         BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25198       else
25199         dir="`$DIRNAME "$path"`"
25200         base="`$BASENAME "$path"`"
25201         BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
25202       fi
25203     fi
25204   fi
25205 
25206             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25207 $as_echo_n "checking for Boot JDK... " >&6; }
25208             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25209 $as_echo "$BOOT_JDK" >&6; }
25210             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
25211 $as_echo_n "checking Boot JDK version... " >&6; }
25212             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
25213             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
25214 $as_echo "$BOOT_JDK_VERSION" >&6; }
25215           fi # end check jdk version
25216         fi # end check javac
25217       fi # end check java
25218     fi # end check boot jdk found
25219   fi
25220 
25221   fi
25222 
25223 
25224     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
25225     if test "x$BOOT_JDK_FOUND" = xmaybe; then
25226       # Do we have a bin/java?
25227       if test ! -x "$BOOT_JDK/bin/java"; then
25228         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
25229 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
25230         BOOT_JDK_FOUND=no
25231       else
25232         # Do we have a bin/javac?
25233         if test ! -x "$BOOT_JDK/bin/javac"; then
25234           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
25235 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
25236           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
25237 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
25238           BOOT_JDK_FOUND=no
25239         else
25240           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
25241           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
25242 
25243           # Extra M4 quote needed to protect [] in grep expression.
25244           FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
25245           if test "x$FOUND_CORRECT_VERSION" = x; then
25246             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect