69068 lines
2.4 MiB
Plaintext
69068 lines
2.4 MiB
Plaintext
#!/bin/bash
|
|
#
|
|
# ##########################################################
|
|
# ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
|
|
# ##########################################################
|
|
#
|
|
#! /bin/sh
|
|
# Guess values for system-dependent variables and create Makefiles.
|
|
# Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
|
|
#
|
|
# Report bugs to <build-dev@openjdk.java.net>.
|
|
#
|
|
#
|
|
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
|
|
#
|
|
#
|
|
# This configure script is free software; the Free Software Foundation
|
|
# gives unlimited permission to copy, distribute and modify it.
|
|
## -------------------- ##
|
|
## M4sh Initialization. ##
|
|
## -------------------- ##
|
|
|
|
# Be more Bourne compatible
|
|
DUALCASE=1; export DUALCASE # for MKS sh
|
|
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
|
|
emulate sh
|
|
NULLCMD=:
|
|
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
|
|
# is contrary to our usage. Disable this feature.
|
|
alias -g '${1+"$@"}'='"$@"'
|
|
setopt NO_GLOB_SUBST
|
|
else
|
|
case `(set -o) 2>/dev/null` in #(
|
|
*posix*) :
|
|
set -o posix ;; #(
|
|
*) :
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
|
|
as_nl='
|
|
'
|
|
export as_nl
|
|
# Printing a long string crashes Solaris 7 /usr/bin/printf.
|
|
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
|
|
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
|
|
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
|
|
# Prefer a ksh shell builtin over an external printf program on Solaris,
|
|
# but without wasting forks for bash or zsh.
|
|
if test -z "$BASH_VERSION$ZSH_VERSION" \
|
|
&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
|
|
as_echo='print -r --'
|
|
as_echo_n='print -rn --'
|
|
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
|
|
as_echo='printf %s\n'
|
|
as_echo_n='printf %s'
|
|
else
|
|
if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
|
|
as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
|
|
as_echo_n='/usr/ucb/echo -n'
|
|
else
|
|
as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
|
|
as_echo_n_body='eval
|
|
arg=$1;
|
|
case $arg in #(
|
|
*"$as_nl"*)
|
|
expr "X$arg" : "X\\(.*\\)$as_nl";
|
|
arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
|
|
esac;
|
|
expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
|
|
'
|
|
export as_echo_n_body
|
|
as_echo_n='sh -c $as_echo_n_body as_echo'
|
|
fi
|
|
export as_echo_body
|
|
as_echo='sh -c $as_echo_body as_echo'
|
|
fi
|
|
|
|
# The user is always right.
|
|
if test "${PATH_SEPARATOR+set}" != set; then
|
|
PATH_SEPARATOR=:
|
|
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
|
|
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
|
|
PATH_SEPARATOR=';'
|
|
}
|
|
fi
|
|
|
|
|
|
# IFS
|
|
# We need space, tab and new line, in precisely that order. Quoting is
|
|
# there to prevent editors from complaining about space-tab.
|
|
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
|
|
# splitting by setting IFS to empty value.)
|
|
IFS=" "" $as_nl"
|
|
|
|
# Find who we are. Look in the path if we contain no directory separator.
|
|
as_myself=
|
|
case $0 in #((
|
|
*[\\/]* ) as_myself=$0 ;;
|
|
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
# We did not find ourselves, most probably we were run as `sh COMMAND'
|
|
# in which case we are not to be found in the path.
|
|
if test "x$as_myself" = x; then
|
|
as_myself=$0
|
|
fi
|
|
if test ! -f "$as_myself"; then
|
|
$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
|
|
exit 1
|
|
fi
|
|
|
|
# Unset variables that we do not need and which cause bugs (e.g. in
|
|
# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
|
|
# suppresses any "Segmentation fault" message there. '((' could
|
|
# trigger a bug in pdksh 5.2.14.
|
|
for as_var in BASH_ENV ENV MAIL MAILPATH
|
|
do eval test x\${$as_var+set} = xset \
|
|
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
|
|
done
|
|
PS1='$ '
|
|
PS2='> '
|
|
PS4='+ '
|
|
|
|
# NLS nuisances.
|
|
LC_ALL=C
|
|
export LC_ALL
|
|
LANGUAGE=C
|
|
export LANGUAGE
|
|
|
|
# CDPATH.
|
|
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
|
|
|
|
# Use a proper internal environment variable to ensure we don't fall
|
|
# into an infinite loop, continuously re-executing ourselves.
|
|
if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
|
|
_as_can_reexec=no; export _as_can_reexec;
|
|
# We cannot yet assume a decent shell, so we have to provide a
|
|
# neutralization value for shells without unset; and this also
|
|
# works around shells that cannot unset nonexistent variables.
|
|
# Preserve -v and -x to the replacement shell.
|
|
BASH_ENV=/dev/null
|
|
ENV=/dev/null
|
|
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
|
|
case $- in # ((((
|
|
*v*x* | *x*v* ) as_opts=-vx ;;
|
|
*v* ) as_opts=-v ;;
|
|
*x* ) as_opts=-x ;;
|
|
* ) as_opts= ;;
|
|
esac
|
|
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
|
|
# Admittedly, this is quite paranoid, since all the known shells bail
|
|
# out after a failed `exec'.
|
|
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
|
|
as_fn_exit 255
|
|
fi
|
|
# We don't want this to propagate to other subprocesses.
|
|
{ _as_can_reexec=; unset _as_can_reexec;}
|
|
if test "x$CONFIG_SHELL" = x; then
|
|
as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
|
|
emulate sh
|
|
NULLCMD=:
|
|
# Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
|
|
# is contrary to our usage. Disable this feature.
|
|
alias -g '\${1+\"\$@\"}'='\"\$@\"'
|
|
setopt NO_GLOB_SUBST
|
|
else
|
|
case \`(set -o) 2>/dev/null\` in #(
|
|
*posix*) :
|
|
set -o posix ;; #(
|
|
*) :
|
|
;;
|
|
esac
|
|
fi
|
|
"
|
|
as_required="as_fn_return () { (exit \$1); }
|
|
as_fn_success () { as_fn_return 0; }
|
|
as_fn_failure () { as_fn_return 1; }
|
|
as_fn_ret_success () { return 0; }
|
|
as_fn_ret_failure () { return 1; }
|
|
|
|
exitcode=0
|
|
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
|
|
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
|
|
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
|
|
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
|
|
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
|
|
|
|
else
|
|
exitcode=1; echo positional parameters were not saved.
|
|
fi
|
|
test x\$exitcode = x0 || exit 1
|
|
test -x / || exit 1"
|
|
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
|
|
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
|
|
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
|
|
test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
|
|
test \$(( 1 + 1 )) = 2 || exit 1"
|
|
if (eval "$as_required") 2>/dev/null; then :
|
|
as_have_required=yes
|
|
else
|
|
as_have_required=no
|
|
fi
|
|
if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
|
|
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
as_found=false
|
|
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
as_found=:
|
|
case $as_dir in #(
|
|
/*)
|
|
for as_base in sh bash ksh sh5; do
|
|
# Try only shells that exist, to save several forks.
|
|
as_shell=$as_dir/$as_base
|
|
if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
|
|
{ $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
|
|
CONFIG_SHELL=$as_shell as_have_required=yes
|
|
if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
|
|
break 2
|
|
fi
|
|
fi
|
|
done;;
|
|
esac
|
|
as_found=false
|
|
done
|
|
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
|
|
{ $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
|
|
CONFIG_SHELL=$SHELL as_have_required=yes
|
|
fi; }
|
|
IFS=$as_save_IFS
|
|
|
|
|
|
if test "x$CONFIG_SHELL" != x; then :
|
|
export CONFIG_SHELL
|
|
# We cannot yet assume a decent shell, so we have to provide a
|
|
# neutralization value for shells without unset; and this also
|
|
# works around shells that cannot unset nonexistent variables.
|
|
# Preserve -v and -x to the replacement shell.
|
|
BASH_ENV=/dev/null
|
|
ENV=/dev/null
|
|
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
|
|
case $- in # ((((
|
|
*v*x* | *x*v* ) as_opts=-vx ;;
|
|
*v* ) as_opts=-v ;;
|
|
*x* ) as_opts=-x ;;
|
|
* ) as_opts= ;;
|
|
esac
|
|
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
|
|
# Admittedly, this is quite paranoid, since all the known shells bail
|
|
# out after a failed `exec'.
|
|
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
|
|
exit 255
|
|
fi
|
|
|
|
if test x$as_have_required = xno; then :
|
|
$as_echo "$0: This script requires a shell more modern than all"
|
|
$as_echo "$0: the shells that I found on your system."
|
|
if test x${ZSH_VERSION+set} = xset ; then
|
|
$as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
|
|
$as_echo "$0: be upgraded to zsh 4.3.4 or later."
|
|
else
|
|
$as_echo "$0: Please tell bug-autoconf@gnu.org and
|
|
$0: build-dev@openjdk.java.net about your system, including
|
|
$0: any error possibly output before this message. Then
|
|
$0: install a modern shell, or manually run the script
|
|
$0: under such a shell if you do have one."
|
|
fi
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
SHELL=${CONFIG_SHELL-/bin/sh}
|
|
export SHELL
|
|
# Unset more variables known to interfere with behavior of common tools.
|
|
CLICOLOR_FORCE= GREP_OPTIONS=
|
|
unset CLICOLOR_FORCE GREP_OPTIONS
|
|
|
|
## --------------------- ##
|
|
## M4sh Shell Functions. ##
|
|
## --------------------- ##
|
|
# as_fn_unset VAR
|
|
# ---------------
|
|
# Portably unset VAR.
|
|
as_fn_unset ()
|
|
{
|
|
{ eval $1=; unset $1;}
|
|
}
|
|
as_unset=as_fn_unset
|
|
|
|
# as_fn_set_status STATUS
|
|
# -----------------------
|
|
# Set $? to STATUS, without forking.
|
|
as_fn_set_status ()
|
|
{
|
|
return $1
|
|
} # as_fn_set_status
|
|
|
|
# as_fn_exit STATUS
|
|
# -----------------
|
|
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
|
|
as_fn_exit ()
|
|
{
|
|
set +e
|
|
as_fn_set_status $1
|
|
exit $1
|
|
} # as_fn_exit
|
|
|
|
# as_fn_mkdir_p
|
|
# -------------
|
|
# Create "$as_dir" as a directory, including parents if necessary.
|
|
as_fn_mkdir_p ()
|
|
{
|
|
|
|
case $as_dir in #(
|
|
-*) as_dir=./$as_dir;;
|
|
esac
|
|
test -d "$as_dir" || eval $as_mkdir_p || {
|
|
as_dirs=
|
|
while :; do
|
|
case $as_dir in #(
|
|
*\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
|
|
*) as_qdir=$as_dir;;
|
|
esac
|
|
as_dirs="'$as_qdir' $as_dirs"
|
|
as_dir=`$as_dirname -- "$as_dir" ||
|
|
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
|
|
X"$as_dir" : 'X\(//\)[^/]' \| \
|
|
X"$as_dir" : 'X\(//\)$' \| \
|
|
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
|
|
$as_echo X"$as_dir" |
|
|
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)[^/].*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q'`
|
|
test -d "$as_dir" && break
|
|
done
|
|
test -z "$as_dirs" || eval "mkdir $as_dirs"
|
|
} || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
|
|
|
|
|
|
} # as_fn_mkdir_p
|
|
|
|
# as_fn_executable_p FILE
|
|
# -----------------------
|
|
# Test if FILE is an executable regular file.
|
|
as_fn_executable_p ()
|
|
{
|
|
test -f "$1" && test -x "$1"
|
|
} # as_fn_executable_p
|
|
# as_fn_append VAR VALUE
|
|
# ----------------------
|
|
# Append the text in VALUE to the end of the definition contained in VAR. Take
|
|
# advantage of any shell optimizations that allow amortized linear growth over
|
|
# repeated appends, instead of the typical quadratic growth present in naive
|
|
# implementations.
|
|
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
|
|
eval 'as_fn_append ()
|
|
{
|
|
eval $1+=\$2
|
|
}'
|
|
else
|
|
as_fn_append ()
|
|
{
|
|
eval $1=\$$1\$2
|
|
}
|
|
fi # as_fn_append
|
|
|
|
# as_fn_arith ARG...
|
|
# ------------------
|
|
# Perform arithmetic evaluation on the ARGs, and store the result in the
|
|
# global $as_val. Take advantage of shells that can avoid forks. The arguments
|
|
# must be portable across $(()) and expr.
|
|
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
|
|
eval 'as_fn_arith ()
|
|
{
|
|
as_val=$(( $* ))
|
|
}'
|
|
else
|
|
as_fn_arith ()
|
|
{
|
|
as_val=`expr "$@" || test $? -eq 1`
|
|
}
|
|
fi # as_fn_arith
|
|
|
|
|
|
# as_fn_error STATUS ERROR [LINENO LOG_FD]
|
|
# ----------------------------------------
|
|
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
|
|
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
|
|
# script with STATUS, using 1 if that was 0.
|
|
as_fn_error ()
|
|
{
|
|
as_status=$1; test $as_status -eq 0 && as_status=1
|
|
if test "$4"; then
|
|
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
|
|
fi
|
|
$as_echo "$as_me: error: $2" >&2
|
|
as_fn_exit $as_status
|
|
} # as_fn_error
|
|
|
|
if expr a : '\(a\)' >/dev/null 2>&1 &&
|
|
test "X`expr 00001 : '.*\(...\)'`" = X001; then
|
|
as_expr=expr
|
|
else
|
|
as_expr=false
|
|
fi
|
|
|
|
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
|
|
as_basename=basename
|
|
else
|
|
as_basename=false
|
|
fi
|
|
|
|
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
|
|
as_dirname=dirname
|
|
else
|
|
as_dirname=false
|
|
fi
|
|
|
|
as_me=`$as_basename -- "$0" ||
|
|
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
|
|
X"$0" : 'X\(//\)$' \| \
|
|
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
|
|
$as_echo X/"$0" |
|
|
sed '/^.*\/\([^/][^/]*\)\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\/\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\/\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q'`
|
|
|
|
# Avoid depending upon Character Ranges.
|
|
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
|
|
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
|
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
|
|
as_cr_digits='0123456789'
|
|
as_cr_alnum=$as_cr_Letters$as_cr_digits
|
|
|
|
|
|
as_lineno_1=$LINENO as_lineno_1a=$LINENO
|
|
as_lineno_2=$LINENO as_lineno_2a=$LINENO
|
|
eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
|
|
test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
|
|
# Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
|
|
sed -n '
|
|
p
|
|
/[$]LINENO/=
|
|
' <$as_myself |
|
|
sed '
|
|
s/[$]LINENO.*/&-/
|
|
t lineno
|
|
b
|
|
:lineno
|
|
N
|
|
:loop
|
|
s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
|
|
t loop
|
|
s/-\n.*//
|
|
' >$as_me.lineno &&
|
|
chmod +x "$as_me.lineno" ||
|
|
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
|
|
|
|
# If we had to re-execute with $CONFIG_SHELL, we're ensured to have
|
|
# already done that, so ensure we don't try to do so again and fall
|
|
# in an infinite loop. This has already happened in practice.
|
|
_as_can_reexec=no; export _as_can_reexec
|
|
# Don't try to exec as it changes $[0], causing all sort of problems
|
|
# (the dirname of $[0] is not the place where we might find the
|
|
# original and so on. Autoconf is especially sensitive to this).
|
|
. "./$as_me.lineno"
|
|
# Exit status is that of the last command.
|
|
exit
|
|
}
|
|
|
|
ECHO_C= ECHO_N= ECHO_T=
|
|
case `echo -n x` in #(((((
|
|
-n*)
|
|
case `echo 'xy\c'` in
|
|
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
|
|
xy) ECHO_C='\c';;
|
|
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
|
|
ECHO_T=' ';;
|
|
esac;;
|
|
*)
|
|
ECHO_N='-n';;
|
|
esac
|
|
|
|
rm -f conf$$ conf$$.exe conf$$.file
|
|
if test -d conf$$.dir; then
|
|
rm -f conf$$.dir/conf$$.file
|
|
else
|
|
rm -f conf$$.dir
|
|
mkdir conf$$.dir 2>/dev/null
|
|
fi
|
|
if (echo >conf$$.file) 2>/dev/null; then
|
|
if ln -s conf$$.file conf$$ 2>/dev/null; then
|
|
as_ln_s='ln -s'
|
|
# ... but there are two gotchas:
|
|
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
|
|
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
|
|
# In both cases, we have to default to `cp -pR'.
|
|
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
|
|
as_ln_s='cp -pR'
|
|
elif ln conf$$.file conf$$ 2>/dev/null; then
|
|
as_ln_s=ln
|
|
else
|
|
as_ln_s='cp -pR'
|
|
fi
|
|
else
|
|
as_ln_s='cp -pR'
|
|
fi
|
|
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
|
|
rmdir conf$$.dir 2>/dev/null
|
|
|
|
if mkdir -p . 2>/dev/null; then
|
|
as_mkdir_p='mkdir -p "$as_dir"'
|
|
else
|
|
test -d ./-p && rmdir ./-p
|
|
as_mkdir_p=false
|
|
fi
|
|
|
|
as_test_x='test -x'
|
|
as_executable_p=as_fn_executable_p
|
|
|
|
# Sed expression to map a string onto a valid CPP name.
|
|
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
|
|
|
|
# Sed expression to map a string onto a valid variable name.
|
|
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
|
|
|
|
|
|
test -n "$DJDIR" || exec 7<&0 </dev/null
|
|
exec 6>&1
|
|
|
|
# Name of the host.
|
|
# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
|
|
# so uname gets run too.
|
|
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
|
|
|
|
#
|
|
# Initializations.
|
|
#
|
|
ac_default_prefix=/usr/local
|
|
ac_clean_files=
|
|
ac_config_libobj_dir=.
|
|
LIBOBJS=
|
|
cross_compiling=no
|
|
subdirs=
|
|
MFLAGS=
|
|
MAKEFLAGS=
|
|
|
|
# Identity of this package.
|
|
PACKAGE_NAME='OpenJDK'
|
|
PACKAGE_TARNAME='openjdk'
|
|
PACKAGE_VERSION='jdk9'
|
|
PACKAGE_STRING='OpenJDK jdk9'
|
|
PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
|
|
PACKAGE_URL='http://openjdk.java.net'
|
|
|
|
# Factoring default headers for most tests.
|
|
ac_includes_default="\
|
|
#include <stdio.h>
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
# include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_STAT_H
|
|
# include <sys/stat.h>
|
|
#endif
|
|
#ifdef STDC_HEADERS
|
|
# include <stdlib.h>
|
|
# include <stddef.h>
|
|
#else
|
|
# ifdef HAVE_STDLIB_H
|
|
# include <stdlib.h>
|
|
# endif
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
|
|
# include <memory.h>
|
|
# endif
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
#ifdef HAVE_INTTYPES_H
|
|
# include <inttypes.h>
|
|
#endif
|
|
#ifdef HAVE_STDINT_H
|
|
# include <stdint.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif"
|
|
|
|
ac_subst_vars='LTLIBOBJS
|
|
LIBOBJS
|
|
CFLAGS_CCACHE
|
|
CCACHE
|
|
USE_PRECOMPILED_HEADER
|
|
BUILD_ICECC
|
|
ICECC
|
|
ICECC_WRAPPER
|
|
ICECC_CREATE_ENV
|
|
ICECC_CMD
|
|
ENABLE_JAVAC_SERVER
|
|
ENABLE_SJAVAC
|
|
SJAVAC_SERVER_JAVA_FLAGS
|
|
SJAVAC_SERVER_JAVA
|
|
JAVA_TOOL_FLAGS_SMALL
|
|
JAVA_FLAGS_SMALL
|
|
JAVA_FLAGS_JAVAC
|
|
BOOTCYCLE_JVM_ARGS_BIG
|
|
JAVA_FLAGS_BIG
|
|
JAVA_FLAGS
|
|
TEST_JOBS
|
|
JOBS
|
|
MEMORY_SIZE
|
|
NUM_CORES
|
|
ENABLE_GENERATE_CLASSLIST
|
|
BUILD_FAILURE_HANDLER
|
|
ENABLE_INTREE_EC
|
|
VALID_JVM_FEATURES
|
|
JVM_FEATURES_custom
|
|
JVM_FEATURES_zeroshark
|
|
JVM_FEATURES_zero
|
|
JVM_FEATURES_minimal
|
|
JVM_FEATURES_core
|
|
JVM_FEATURES_client
|
|
JVM_FEATURES_server
|
|
INCLUDE_GRAAL
|
|
STLPORT_LIB
|
|
LIBZIP_CAN_USE_MMAP
|
|
LIBDL
|
|
LIBM
|
|
USE_EXTERNAL_LCMS
|
|
LCMS_LIBS
|
|
LCMS_CFLAGS
|
|
USE_EXTERNAL_LIBZ
|
|
USE_EXTERNAL_LIBPNG
|
|
PNG_LIBS
|
|
PNG_CFLAGS
|
|
USE_EXTERNAL_LIBGIF
|
|
USE_EXTERNAL_LIBJPEG
|
|
LLVM_LIBS
|
|
LLVM_LDFLAGS
|
|
LLVM_CFLAGS
|
|
LLVM_CONFIG
|
|
LIBFFI_LIB_FILE
|
|
ENABLE_LIBFFI_BUNDLING
|
|
LIBFFI_LIBS
|
|
LIBFFI_CFLAGS
|
|
ALSA_LIBS
|
|
ALSA_CFLAGS
|
|
FREETYPE_LICENSE
|
|
FREETYPE_BUNDLE_LIB_PATH
|
|
FREETYPE_LIBS
|
|
FREETYPE_CFLAGS
|
|
CUPS_CFLAGS
|
|
X_EXTRA_LIBS
|
|
X_LIBS
|
|
X_PRE_LIBS
|
|
X_CFLAGS
|
|
XMKMF
|
|
MSVCP_DLL
|
|
MSVCR_DLL
|
|
LIBCXX
|
|
FIXPATH_DETACH_FLAG
|
|
FIXPATH
|
|
BUILD_GTEST
|
|
ENABLE_CDS
|
|
ENABLE_AOT
|
|
GCOV_ENABLED
|
|
ZIP_EXTERNAL_DEBUG_SYMBOLS
|
|
COPY_DEBUG_SYMBOLS
|
|
COMPILE_WITH_DEBUG_SYMBOLS
|
|
CFLAGS_WARNINGS_ARE_ERRORS
|
|
BUILD_CC_DISABLE_WARNING_PREFIX
|
|
DISABLE_WARNING_PREFIX
|
|
WARNINGS_AS_ERRORS
|
|
COMPILER_SUPPORTS_TARGET_BITS_FLAG
|
|
LDFLAGS_TESTEXE
|
|
LDFLAGS_TESTLIB
|
|
CXXFLAGS_TESTEXE
|
|
CXXFLAGS_TESTLIB
|
|
CFLAGS_TESTEXE
|
|
CFLAGS_TESTLIB
|
|
OPENJDK_BUILD_JVM_LIBS
|
|
OPENJDK_BUILD_JVM_ASFLAGS
|
|
OPENJDK_BUILD_JVM_LDFLAGS
|
|
OPENJDK_BUILD_JVM_CFLAGS
|
|
OPENJDK_BUILD_LDFLAGS_HASH_STYLE
|
|
OPENJDK_BUILD_LDFLAGS_CXX_JDK
|
|
OPENJDK_BUILD_JDKEXE_LIBS
|
|
OPENJDK_BUILD_JDKLIB_LIBS
|
|
OPENJDK_BUILD_LDFLAGS_JDKEXE
|
|
OPENJDK_BUILD_LDFLAGS_JDKLIB
|
|
OPENJDK_BUILD_CXXFLAGS_JDKEXE
|
|
OPENJDK_BUILD_CXXFLAGS_JDKLIB
|
|
OPENJDK_BUILD_CFLAGS_JDKEXE
|
|
OPENJDK_BUILD_CFLAGS_JDKLIB
|
|
OPENJDK_BUILD_CXXSTD_CXXFLAG
|
|
JVM_LIBS
|
|
JVM_ASFLAGS
|
|
JVM_LDFLAGS
|
|
JVM_CFLAGS
|
|
LDFLAGS_HASH_STYLE
|
|
LDFLAGS_CXX_JDK
|
|
JDKEXE_LIBS
|
|
JDKLIB_LIBS
|
|
LDFLAGS_JDKEXE
|
|
LDFLAGS_JDKLIB
|
|
CXXFLAGS_JDKEXE
|
|
CXXFLAGS_JDKLIB
|
|
CFLAGS_JDKEXE
|
|
CFLAGS_JDKLIB
|
|
MACOSX_VERSION_MAX
|
|
MACOSX_VERSION_MIN
|
|
CXXSTD_CXXFLAG
|
|
JDK_ARCH_ABI_PROP_NAME
|
|
CXX_O_FLAG_SIZE
|
|
CXX_O_FLAG_NONE
|
|
CXX_O_FLAG_DEBUG
|
|
CXX_O_FLAG_NORM
|
|
CXX_O_FLAG_HI
|
|
CXX_O_FLAG_HIGHEST
|
|
CXX_O_FLAG_HIGHEST_JVM
|
|
C_O_FLAG_SIZE
|
|
C_O_FLAG_NONE
|
|
C_O_FLAG_DEBUG
|
|
C_O_FLAG_NORM
|
|
C_O_FLAG_HI
|
|
C_O_FLAG_HIGHEST
|
|
C_O_FLAG_HIGHEST_JVM
|
|
JVM_CFLAGS_SYMBOLS
|
|
CXXFLAGS_DEBUG_SYMBOLS
|
|
CFLAGS_DEBUG_SYMBOLS
|
|
CXX_FLAG_DEPS
|
|
C_FLAG_DEPS
|
|
SHARED_LIBRARY_FLAGS
|
|
SET_SHARED_LIBRARY_MAPFILE
|
|
SET_SHARED_LIBRARY_NAME
|
|
SET_SHARED_LIBRARY_ORIGIN
|
|
SET_EXECUTABLE_ORIGIN
|
|
CXX_FLAG_REORDER
|
|
C_FLAG_REORDER
|
|
JVM_RCFLAGS
|
|
RC_FLAGS
|
|
AR_OUT_OPTION
|
|
LD_OUT_OPTION
|
|
EXE_OUT_OPTION
|
|
CC_OUT_OPTION
|
|
STRIPFLAGS
|
|
ARFLAGS
|
|
COMPILER_BINDCMD_FILE_FLAG
|
|
COMPILER_COMMAND_FILE_FLAG
|
|
COMPILER_TARGET_BITS_FLAG
|
|
JIB_JAR
|
|
JT_HOME
|
|
JTREGEXE
|
|
HOTSPOT_TOOLCHAIN_TYPE
|
|
USING_BROKEN_SUSE_LD
|
|
PACKAGE_PATH
|
|
BUILD_AS
|
|
BUILD_LDCXX
|
|
BUILD_LD
|
|
BUILD_STRIP
|
|
BUILD_OBJCOPY
|
|
BUILD_AR
|
|
BUILD_NM
|
|
BUILD_CXX
|
|
BUILD_CC
|
|
BUILD_SYSROOT_LDFLAGS
|
|
BUILD_SYSROOT_CFLAGS
|
|
ac_ct_OBJDUMP
|
|
OBJDUMP
|
|
ac_ct_OBJCOPY
|
|
OBJCOPY
|
|
ac_ct_NM
|
|
ac_ct_STRIP
|
|
GNM
|
|
NM
|
|
STRIP
|
|
MSBUILD
|
|
DUMPBIN
|
|
RC
|
|
MT
|
|
LIPO
|
|
ac_ct_AR
|
|
AR
|
|
AS
|
|
LDCXX
|
|
LD
|
|
CXXCPP
|
|
CPP
|
|
CXX_VERSION_NUMBER
|
|
CC_VERSION_NUMBER
|
|
ac_ct_CXX
|
|
CXXFLAGS
|
|
CXX
|
|
TOOLCHAIN_PATH_CXX
|
|
POTENTIAL_CXX
|
|
OBJEXT
|
|
EXEEXT
|
|
ac_ct_CC
|
|
CPPFLAGS
|
|
LDFLAGS
|
|
CFLAGS
|
|
CC
|
|
TOOLCHAIN_PATH_CC
|
|
POTENTIAL_CC
|
|
TOOLCHAIN_VERSION
|
|
VS_LIB
|
|
VS_INCLUDE
|
|
VS_PATH
|
|
CYGWIN_LINK
|
|
SYSROOT_LDFLAGS
|
|
SYSROOT_CFLAGS
|
|
EXTRA_LDFLAGS
|
|
EXTRA_CXXFLAGS
|
|
EXTRA_CFLAGS
|
|
EXE_SUFFIX
|
|
OBJ_SUFFIX
|
|
STATIC_LIBRARY
|
|
SHARED_LIBRARY
|
|
STATIC_LIBRARY_SUFFIX
|
|
SHARED_LIBRARY_SUFFIX
|
|
LIBRARY_PREFIX
|
|
TOOLCHAIN_TYPE
|
|
STATIC_BUILD
|
|
IMPORT_MODULES_MAKE
|
|
IMPORT_MODULES_SRC
|
|
IMPORT_MODULES_MAN
|
|
IMPORT_MODULES_LEGAL
|
|
IMPORT_MODULES_CONF
|
|
IMPORT_MODULES_LIBS
|
|
IMPORT_MODULES_CMDS
|
|
IMPORT_MODULES_CLASSES
|
|
BUILD_OUTPUT
|
|
JDK_TOPDIR
|
|
NASHORN_TOPDIR
|
|
HOTSPOT_TOPDIR
|
|
JAXWS_TOPDIR
|
|
JAXP_TOPDIR
|
|
CORBA_TOPDIR
|
|
LANGTOOLS_TOPDIR
|
|
EXTERNAL_BUILDJDK
|
|
BUILD_JDK
|
|
CREATE_BUILDJDK
|
|
JLINK
|
|
JMOD
|
|
JAVAC_FLAGS
|
|
BOOT_JDK_MODULAR
|
|
BOOT_JDK_SOURCETARGET
|
|
JARSIGNER
|
|
JAR
|
|
JAVAH
|
|
JAVAC
|
|
JAVA
|
|
BOOT_JDK
|
|
JAVA_CHECK
|
|
JAVAC_CHECK
|
|
VERSION_IS_GA
|
|
VERSION_SHORT
|
|
VERSION_STRING
|
|
VERSION_NUMBER_FOUR_POSITIONS
|
|
VERSION_NUMBER
|
|
VERSION_OPT
|
|
VERSION_BUILD
|
|
VERSION_PRE
|
|
VERSION_PATCH
|
|
VERSION_SECURITY
|
|
VERSION_MINOR
|
|
VERSION_MAJOR
|
|
MACOSX_BUNDLE_ID_BASE
|
|
MACOSX_BUNDLE_NAME_BASE
|
|
HOTSPOT_VM_DISTRO
|
|
COMPANY_NAME
|
|
JDK_RC_PLATFORM_NAME
|
|
PRODUCT_SUFFIX
|
|
PRODUCT_NAME
|
|
LAUNCHER_NAME
|
|
JLINK_KEEP_PACKAGED_MODULES
|
|
COPYRIGHT_YEAR
|
|
COMPRESS_JARS
|
|
INCLUDE_SA
|
|
UNLIMITED_CRYPTO
|
|
CACERTS_FILE
|
|
ENABLE_FULL_DOCS
|
|
ENABLE_HEADLESS_ONLY
|
|
DEFAULT_MAKE_TARGET
|
|
OS_VERSION_MICRO
|
|
OS_VERSION_MINOR
|
|
OS_VERSION_MAJOR
|
|
PKG_CONFIG
|
|
BASH_ARGS
|
|
SETFILE
|
|
CODESIGN
|
|
XATTR
|
|
DSYMUTIL
|
|
IS_GNU_TIME
|
|
PATCH
|
|
DTRACE
|
|
FLOCK
|
|
TIME
|
|
STAT
|
|
HG
|
|
DOT
|
|
READELF
|
|
OTOOL
|
|
LDD
|
|
ZIPEXE
|
|
UNZIP
|
|
TAR_SUPPORTS_TRANSFORM
|
|
TAR_INCLUDE_PARAM
|
|
TAR_CREATE_EXTRA_PARAM
|
|
TAR_TYPE
|
|
FIND_DELETE
|
|
OUTPUT_SYNC
|
|
OUTPUT_SYNC_SUPPORTED
|
|
CHECK_TOOLSDIR_MAKE
|
|
CHECK_TOOLSDIR_GMAKE
|
|
CHECK_MAKE
|
|
CHECK_GMAKE
|
|
MAKE
|
|
PKGHANDLER
|
|
CONFIGURESUPPORT_OUTPUTDIR
|
|
OUTPUT_ROOT
|
|
CONF_NAME
|
|
SPEC
|
|
SDKROOT
|
|
XCODEBUILD
|
|
JVM_VARIANT_MAIN
|
|
VALID_JVM_VARIANTS
|
|
JVM_VARIANTS
|
|
DEBUG_LEVEL
|
|
HOTSPOT_DEBUG_LEVEL
|
|
JDK_VARIANT
|
|
USERNAME
|
|
CANONICAL_TOPDIR
|
|
ORIGINAL_TOPDIR
|
|
TOPDIR
|
|
PATH_SEP
|
|
HOTSPOT_BUILD_CPU_DEFINE
|
|
HOTSPOT_BUILD_CPU_ARCH
|
|
HOTSPOT_BUILD_CPU
|
|
HOTSPOT_BUILD_OS_TYPE
|
|
HOTSPOT_BUILD_OS
|
|
OPENJDK_BUILD_BUNDLE_PLATFORM
|
|
OPENJDK_BUILD_OS_EXPORT_DIR
|
|
OPENJDK_BUILD_CPU_OSARCH
|
|
OPENJDK_BUILD_CPU_ISADIR
|
|
OPENJDK_BUILD_CPU_LEGACY_LIB
|
|
OPENJDK_BUILD_CPU_LEGACY
|
|
HOTSPOT_TARGET_CPU_DEFINE
|
|
HOTSPOT_TARGET_CPU_ARCH
|
|
HOTSPOT_TARGET_CPU
|
|
HOTSPOT_TARGET_OS_TYPE
|
|
HOTSPOT_TARGET_OS
|
|
DEFINE_CROSS_COMPILE_ARCH
|
|
OPENJDK_TARGET_BUNDLE_PLATFORM
|
|
OPENJDK_TARGET_OS_EXPORT_DIR
|
|
OPENJDK_TARGET_CPU_OSARCH
|
|
OPENJDK_TARGET_CPU_ISADIR
|
|
OPENJDK_TARGET_CPU_LEGACY_LIB
|
|
OPENJDK_TARGET_CPU_LEGACY
|
|
RELEASE_FILE_OS_ARCH
|
|
RELEASE_FILE_OS_NAME
|
|
OPENJDK_MODULE_TARGET_PLATFORM
|
|
COMPILE_TYPE
|
|
OPENJDK_TARGET_CPU_ENDIAN
|
|
OPENJDK_TARGET_CPU_BITS
|
|
OPENJDK_TARGET_CPU_ARCH
|
|
OPENJDK_TARGET_CPU
|
|
OPENJDK_TARGET_OS_ENV
|
|
OPENJDK_TARGET_OS_TYPE
|
|
OPENJDK_TARGET_OS
|
|
OPENJDK_BUILD_CPU_ENDIAN
|
|
OPENJDK_BUILD_CPU_BITS
|
|
OPENJDK_BUILD_CPU_ARCH
|
|
OPENJDK_BUILD_CPU
|
|
OPENJDK_BUILD_OS_ENV
|
|
OPENJDK_BUILD_OS_TYPE
|
|
OPENJDK_BUILD_OS
|
|
OPENJDK_BUILD_AUTOCONF_NAME
|
|
OPENJDK_TARGET_AUTOCONF_NAME
|
|
target_os
|
|
target_vendor
|
|
target_cpu
|
|
target
|
|
host_os
|
|
host_vendor
|
|
host_cpu
|
|
host
|
|
build_os
|
|
build_vendor
|
|
build_cpu
|
|
build
|
|
PANDOC
|
|
NICE
|
|
CPIO
|
|
DF
|
|
READLINK
|
|
CYGPATH
|
|
SED
|
|
FGREP
|
|
EGREP
|
|
GREP
|
|
AWK
|
|
XARGS
|
|
WHICH
|
|
WC
|
|
UNIQ
|
|
UNAME
|
|
TR
|
|
TOUCH
|
|
TEE
|
|
TAR
|
|
TAIL
|
|
SORT
|
|
SH
|
|
RMDIR
|
|
RM
|
|
PRINTF
|
|
NAWK
|
|
MV
|
|
MKTEMP
|
|
MKDIR
|
|
LS
|
|
LN
|
|
GZIP
|
|
GUNZIP
|
|
HEAD
|
|
FIND
|
|
FILE
|
|
EXPR
|
|
ECHO
|
|
DIRNAME
|
|
DIFF
|
|
DATE
|
|
CUT
|
|
CP
|
|
COMM
|
|
CMP
|
|
CHMOD
|
|
CAT
|
|
BASH
|
|
BASENAME
|
|
DATE_WHEN_CONFIGURED
|
|
ORIGINAL_PATH
|
|
CONFIGURE_COMMAND_LINE
|
|
target_alias
|
|
host_alias
|
|
build_alias
|
|
LIBS
|
|
ECHO_T
|
|
ECHO_N
|
|
ECHO_C
|
|
DEFS
|
|
mandir
|
|
localedir
|
|
libdir
|
|
psdir
|
|
pdfdir
|
|
dvidir
|
|
htmldir
|
|
infodir
|
|
docdir
|
|
oldincludedir
|
|
includedir
|
|
localstatedir
|
|
sharedstatedir
|
|
sysconfdir
|
|
datadir
|
|
datarootdir
|
|
libexecdir
|
|
sbindir
|
|
bindir
|
|
program_transform_name
|
|
prefix
|
|
exec_prefix
|
|
PACKAGE_URL
|
|
PACKAGE_BUGREPORT
|
|
PACKAGE_STRING
|
|
PACKAGE_VERSION
|
|
PACKAGE_TARNAME
|
|
PACKAGE_NAME
|
|
PATH_SEPARATOR
|
|
SHELL'
|
|
ac_subst_files=''
|
|
ac_user_opts='
|
|
enable_option_checking
|
|
with_target_bits
|
|
enable_openjdk_only
|
|
with_custom_make_dir
|
|
with_jdk_variant
|
|
enable_debug
|
|
with_debug_level
|
|
with_jvm_variants
|
|
with_cpu_port
|
|
with_devkit
|
|
with_sys_root
|
|
with_sysroot
|
|
with_tools_dir
|
|
with_toolchain_path
|
|
with_extra_path
|
|
with_sdk_name
|
|
with_conf_name
|
|
with_output_sync
|
|
with_default_make_target
|
|
enable_headless_only
|
|
enable_full_docs
|
|
with_cacerts_file
|
|
enable_unlimited_crypto
|
|
with_copyright_year
|
|
enable_keep_packaged_modules
|
|
with_milestone
|
|
with_update_version
|
|
with_user_release_suffix
|
|
with_build_number
|
|
with_version_string
|
|
with_version_pre
|
|
with_version_opt
|
|
with_version_build
|
|
with_version_major
|
|
with_version_minor
|
|
with_version_security
|
|
with_version_patch
|
|
with_boot_jdk
|
|
with_build_jdk
|
|
with_add_source_root
|
|
with_override_source_root
|
|
with_adds_and_overrides
|
|
with_override_langtools
|
|
with_override_corba
|
|
with_override_jaxp
|
|
with_override_jaxws
|
|
with_override_hotspot
|
|
with_override_nashorn
|
|
with_override_jdk
|
|
with_import_hotspot
|
|
with_import_modules
|
|
enable_static_build
|
|
with_toolchain_type
|
|
with_extra_cflags
|
|
with_extra_cxxflags
|
|
with_extra_ldflags
|
|
with_toolchain_version
|
|
with_build_devkit
|
|
with_jtreg
|
|
with_jib
|
|
with_abi_profile
|
|
with_macosx_version_max
|
|
enable_warnings_as_errors
|
|
with_native_debug_symbols
|
|
enable_debug_symbols
|
|
enable_zip_debug_info
|
|
enable_native_coverage
|
|
enable_dtrace
|
|
enable_aot
|
|
enable_cds
|
|
enable_hotspot_gtest
|
|
with_stdc__lib
|
|
with_msvcr_dll
|
|
with_msvcp_dll
|
|
with_x
|
|
with_cups
|
|
with_cups_include
|
|
with_freetype
|
|
with_freetype_include
|
|
with_freetype_lib
|
|
with_freetype_src
|
|
enable_freetype_bundling
|
|
with_freetype_license
|
|
with_alsa
|
|
with_alsa_include
|
|
with_alsa_lib
|
|
with_libffi
|
|
with_libffi_include
|
|
with_libffi_lib
|
|
enable_libffi_bundling
|
|
with_libjpeg
|
|
with_giflib
|
|
with_libpng
|
|
with_zlib
|
|
with_lcms
|
|
with_dxsdk
|
|
with_dxsdk_lib
|
|
with_dxsdk_include
|
|
with_jvm_features
|
|
with_jvm_interpreter
|
|
enable_jtreg_failure_handler
|
|
enable_generate_classlist
|
|
with_num_cores
|
|
with_memory_size
|
|
with_jobs
|
|
with_test_jobs
|
|
with_boot_jdk_jvmargs
|
|
with_sjavac_server_java
|
|
enable_sjavac
|
|
enable_javac_server
|
|
enable_icecc
|
|
enable_precompiled_headers
|
|
enable_ccache
|
|
with_ccache_dir
|
|
'
|
|
ac_precious_vars='build_alias
|
|
host_alias
|
|
target_alias
|
|
BASENAME
|
|
BASH
|
|
CAT
|
|
CHMOD
|
|
CMP
|
|
COMM
|
|
CP
|
|
CUT
|
|
DATE
|
|
DIFF
|
|
DIRNAME
|
|
ECHO
|
|
EXPR
|
|
FILE
|
|
FIND
|
|
HEAD
|
|
GUNZIP
|
|
GZIP
|
|
LN
|
|
LS
|
|
MKDIR
|
|
MKTEMP
|
|
MV
|
|
NAWK
|
|
PRINTF
|
|
RM
|
|
RMDIR
|
|
SH
|
|
SORT
|
|
TAIL
|
|
TAR
|
|
TEE
|
|
TOUCH
|
|
TR
|
|
UNAME
|
|
UNIQ
|
|
WC
|
|
WHICH
|
|
XARGS
|
|
AWK
|
|
GREP
|
|
EGREP
|
|
FGREP
|
|
SED
|
|
CYGPATH
|
|
READLINK
|
|
DF
|
|
CPIO
|
|
NICE
|
|
PANDOC
|
|
MAKE
|
|
UNZIP
|
|
ZIPEXE
|
|
LDD
|
|
OTOOL
|
|
READELF
|
|
DOT
|
|
HG
|
|
STAT
|
|
TIME
|
|
FLOCK
|
|
DTRACE
|
|
PATCH
|
|
DSYMUTIL
|
|
XATTR
|
|
CODESIGN
|
|
SETFILE
|
|
PKG_CONFIG
|
|
JAVA
|
|
JAVAC
|
|
JAVAH
|
|
JAR
|
|
JARSIGNER
|
|
CC
|
|
CFLAGS
|
|
LDFLAGS
|
|
LIBS
|
|
CPPFLAGS
|
|
CXX
|
|
CXXFLAGS
|
|
CCC
|
|
CPP
|
|
CXXCPP
|
|
AS
|
|
AR
|
|
LIPO
|
|
STRIP
|
|
NM
|
|
GNM
|
|
OBJCOPY
|
|
OBJDUMP
|
|
BUILD_CC
|
|
BUILD_CXX
|
|
BUILD_NM
|
|
BUILD_AR
|
|
BUILD_OBJCOPY
|
|
BUILD_STRIP
|
|
JTREGEXE
|
|
XMKMF
|
|
FREETYPE_CFLAGS
|
|
FREETYPE_LIBS
|
|
ALSA_CFLAGS
|
|
ALSA_LIBS
|
|
LIBFFI_CFLAGS
|
|
LIBFFI_LIBS
|
|
PNG_CFLAGS
|
|
PNG_LIBS
|
|
LCMS_CFLAGS
|
|
LCMS_LIBS
|
|
ICECC_CMD
|
|
ICECC_CREATE_ENV
|
|
ICECC_WRAPPER
|
|
CCACHE'
|
|
|
|
|
|
# Initialize some variables set by options.
|
|
ac_init_help=
|
|
ac_init_version=false
|
|
ac_unrecognized_opts=
|
|
ac_unrecognized_sep=
|
|
# The variables have the same names as the options, with
|
|
# dashes changed to underlines.
|
|
cache_file=/dev/null
|
|
exec_prefix=NONE
|
|
no_create=
|
|
no_recursion=
|
|
prefix=NONE
|
|
program_prefix=NONE
|
|
program_suffix=NONE
|
|
program_transform_name=s,x,x,
|
|
silent=
|
|
site=
|
|
srcdir=
|
|
verbose=
|
|
x_includes=NONE
|
|
x_libraries=NONE
|
|
|
|
# Installation directory options.
|
|
# These are left unexpanded so users can "make install exec_prefix=/foo"
|
|
# and all the variables that are supposed to be based on exec_prefix
|
|
# by default will actually change.
|
|
# Use braces instead of parens because sh, perl, etc. also accept them.
|
|
# (The list follows the same order as the GNU Coding Standards.)
|
|
bindir='${exec_prefix}/bin'
|
|
sbindir='${exec_prefix}/sbin'
|
|
libexecdir='${exec_prefix}/libexec'
|
|
datarootdir='${prefix}/share'
|
|
datadir='${datarootdir}'
|
|
sysconfdir='${prefix}/etc'
|
|
sharedstatedir='${prefix}/com'
|
|
localstatedir='${prefix}/var'
|
|
includedir='${prefix}/include'
|
|
oldincludedir='/usr/include'
|
|
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
|
|
infodir='${datarootdir}/info'
|
|
htmldir='${docdir}'
|
|
dvidir='${docdir}'
|
|
pdfdir='${docdir}'
|
|
psdir='${docdir}'
|
|
libdir='${exec_prefix}/lib'
|
|
localedir='${datarootdir}/locale'
|
|
mandir='${datarootdir}/man'
|
|
|
|
ac_prev=
|
|
ac_dashdash=
|
|
for ac_option
|
|
do
|
|
# If the previous option needs an argument, assign it.
|
|
if test -n "$ac_prev"; then
|
|
eval $ac_prev=\$ac_option
|
|
ac_prev=
|
|
continue
|
|
fi
|
|
|
|
case $ac_option in
|
|
*=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
|
|
*=) ac_optarg= ;;
|
|
*) ac_optarg=yes ;;
|
|
esac
|
|
|
|
# Accept the important Cygnus configure options, so we can diagnose typos.
|
|
|
|
case $ac_dashdash$ac_option in
|
|
--)
|
|
ac_dashdash=yes ;;
|
|
|
|
-bindir | --bindir | --bindi | --bind | --bin | --bi)
|
|
ac_prev=bindir ;;
|
|
-bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
|
|
bindir=$ac_optarg ;;
|
|
|
|
-build | --build | --buil | --bui | --bu)
|
|
ac_prev=build_alias ;;
|
|
-build=* | --build=* | --buil=* | --bui=* | --bu=*)
|
|
build_alias=$ac_optarg ;;
|
|
|
|
-cache-file | --cache-file | --cache-fil | --cache-fi \
|
|
| --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
|
|
ac_prev=cache_file ;;
|
|
-cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
|
|
| --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
|
|
cache_file=$ac_optarg ;;
|
|
|
|
--config-cache | -C)
|
|
cache_file=config.cache ;;
|
|
|
|
-datadir | --datadir | --datadi | --datad)
|
|
ac_prev=datadir ;;
|
|
-datadir=* | --datadir=* | --datadi=* | --datad=*)
|
|
datadir=$ac_optarg ;;
|
|
|
|
-datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
|
|
| --dataroo | --dataro | --datar)
|
|
ac_prev=datarootdir ;;
|
|
-datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
|
|
| --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
|
|
datarootdir=$ac_optarg ;;
|
|
|
|
-disable-* | --disable-*)
|
|
ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
|
|
# Reject names that are not valid shell variable names.
|
|
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
|
|
as_fn_error $? "invalid feature name: $ac_useropt"
|
|
ac_useropt_orig=$ac_useropt
|
|
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
|
|
case $ac_user_opts in
|
|
*"
|
|
"enable_$ac_useropt"
|
|
"*) ;;
|
|
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
|
|
ac_unrecognized_sep=', ';;
|
|
esac
|
|
eval enable_$ac_useropt=no ;;
|
|
|
|
-docdir | --docdir | --docdi | --doc | --do)
|
|
ac_prev=docdir ;;
|
|
-docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
|
|
docdir=$ac_optarg ;;
|
|
|
|
-dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
|
|
ac_prev=dvidir ;;
|
|
-dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
|
|
dvidir=$ac_optarg ;;
|
|
|
|
-enable-* | --enable-*)
|
|
ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
|
|
# Reject names that are not valid shell variable names.
|
|
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
|
|
as_fn_error $? "invalid feature name: $ac_useropt"
|
|
ac_useropt_orig=$ac_useropt
|
|
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
|
|
case $ac_user_opts in
|
|
*"
|
|
"enable_$ac_useropt"
|
|
"*) ;;
|
|
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
|
|
ac_unrecognized_sep=', ';;
|
|
esac
|
|
eval enable_$ac_useropt=\$ac_optarg ;;
|
|
|
|
-exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
|
|
| --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
|
|
| --exec | --exe | --ex)
|
|
ac_prev=exec_prefix ;;
|
|
-exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
|
|
| --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
|
|
| --exec=* | --exe=* | --ex=*)
|
|
exec_prefix=$ac_optarg ;;
|
|
|
|
-gas | --gas | --ga | --g)
|
|
# Obsolete; use --with-gas.
|
|
with_gas=yes ;;
|
|
|
|
-help | --help | --hel | --he | -h)
|
|
ac_init_help=long ;;
|
|
-help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
|
|
ac_init_help=recursive ;;
|
|
-help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
|
|
ac_init_help=short ;;
|
|
|
|
-host | --host | --hos | --ho)
|
|
ac_prev=host_alias ;;
|
|
-host=* | --host=* | --hos=* | --ho=*)
|
|
host_alias=$ac_optarg ;;
|
|
|
|
-htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
|
|
ac_prev=htmldir ;;
|
|
-htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
|
|
| --ht=*)
|
|
htmldir=$ac_optarg ;;
|
|
|
|
-includedir | --includedir | --includedi | --included | --include \
|
|
| --includ | --inclu | --incl | --inc)
|
|
ac_prev=includedir ;;
|
|
-includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
|
|
| --includ=* | --inclu=* | --incl=* | --inc=*)
|
|
includedir=$ac_optarg ;;
|
|
|
|
-infodir | --infodir | --infodi | --infod | --info | --inf)
|
|
ac_prev=infodir ;;
|
|
-infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
|
|
infodir=$ac_optarg ;;
|
|
|
|
-libdir | --libdir | --libdi | --libd)
|
|
ac_prev=libdir ;;
|
|
-libdir=* | --libdir=* | --libdi=* | --libd=*)
|
|
libdir=$ac_optarg ;;
|
|
|
|
-libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
|
|
| --libexe | --libex | --libe)
|
|
ac_prev=libexecdir ;;
|
|
-libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
|
|
| --libexe=* | --libex=* | --libe=*)
|
|
libexecdir=$ac_optarg ;;
|
|
|
|
-localedir | --localedir | --localedi | --localed | --locale)
|
|
ac_prev=localedir ;;
|
|
-localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
|
|
localedir=$ac_optarg ;;
|
|
|
|
-localstatedir | --localstatedir | --localstatedi | --localstated \
|
|
| --localstate | --localstat | --localsta | --localst | --locals)
|
|
ac_prev=localstatedir ;;
|
|
-localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
|
|
| --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
|
|
localstatedir=$ac_optarg ;;
|
|
|
|
-mandir | --mandir | --mandi | --mand | --man | --ma | --m)
|
|
ac_prev=mandir ;;
|
|
-mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
|
|
mandir=$ac_optarg ;;
|
|
|
|
-nfp | --nfp | --nf)
|
|
# Obsolete; use --without-fp.
|
|
with_fp=no ;;
|
|
|
|
-no-create | --no-create | --no-creat | --no-crea | --no-cre \
|
|
| --no-cr | --no-c | -n)
|
|
no_create=yes ;;
|
|
|
|
-no-recursion | --no-recursion | --no-recursio | --no-recursi \
|
|
| --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
|
|
no_recursion=yes ;;
|
|
|
|
-oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
|
|
| --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
|
|
| --oldin | --oldi | --old | --ol | --o)
|
|
ac_prev=oldincludedir ;;
|
|
-oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
|
|
| --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
|
|
| --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
|
|
oldincludedir=$ac_optarg ;;
|
|
|
|
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
|
|
ac_prev=prefix ;;
|
|
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
|
|
prefix=$ac_optarg ;;
|
|
|
|
-program-prefix | --program-prefix | --program-prefi | --program-pref \
|
|
| --program-pre | --program-pr | --program-p)
|
|
ac_prev=program_prefix ;;
|
|
-program-prefix=* | --program-prefix=* | --program-prefi=* \
|
|
| --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
|
|
program_prefix=$ac_optarg ;;
|
|
|
|
-program-suffix | --program-suffix | --program-suffi | --program-suff \
|
|
| --program-suf | --program-su | --program-s)
|
|
ac_prev=program_suffix ;;
|
|
-program-suffix=* | --program-suffix=* | --program-suffi=* \
|
|
| --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
|
|
program_suffix=$ac_optarg ;;
|
|
|
|
-program-transform-name | --program-transform-name \
|
|
| --program-transform-nam | --program-transform-na \
|
|
| --program-transform-n | --program-transform- \
|
|
| --program-transform | --program-transfor \
|
|
| --program-transfo | --program-transf \
|
|
| --program-trans | --program-tran \
|
|
| --progr-tra | --program-tr | --program-t)
|
|
ac_prev=program_transform_name ;;
|
|
-program-transform-name=* | --program-transform-name=* \
|
|
| --program-transform-nam=* | --program-transform-na=* \
|
|
| --program-transform-n=* | --program-transform-=* \
|
|
| --program-transform=* | --program-transfor=* \
|
|
| --program-transfo=* | --program-transf=* \
|
|
| --program-trans=* | --program-tran=* \
|
|
| --progr-tra=* | --program-tr=* | --program-t=*)
|
|
program_transform_name=$ac_optarg ;;
|
|
|
|
-pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
|
|
ac_prev=pdfdir ;;
|
|
-pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
|
|
pdfdir=$ac_optarg ;;
|
|
|
|
-psdir | --psdir | --psdi | --psd | --ps)
|
|
ac_prev=psdir ;;
|
|
-psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
|
|
psdir=$ac_optarg ;;
|
|
|
|
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
|
|
| -silent | --silent | --silen | --sile | --sil)
|
|
silent=yes ;;
|
|
|
|
-sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
|
|
ac_prev=sbindir ;;
|
|
-sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
|
|
| --sbi=* | --sb=*)
|
|
sbindir=$ac_optarg ;;
|
|
|
|
-sharedstatedir | --sharedstatedir | --sharedstatedi \
|
|
| --sharedstated | --sharedstate | --sharedstat | --sharedsta \
|
|
| --sharedst | --shareds | --shared | --share | --shar \
|
|
| --sha | --sh)
|
|
ac_prev=sharedstatedir ;;
|
|
-sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
|
|
| --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
|
|
| --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
|
|
| --sha=* | --sh=*)
|
|
sharedstatedir=$ac_optarg ;;
|
|
|
|
-site | --site | --sit)
|
|
ac_prev=site ;;
|
|
-site=* | --site=* | --sit=*)
|
|
site=$ac_optarg ;;
|
|
|
|
-srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
|
|
ac_prev=srcdir ;;
|
|
-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
|
|
srcdir=$ac_optarg ;;
|
|
|
|
-sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
|
|
| --syscon | --sysco | --sysc | --sys | --sy)
|
|
ac_prev=sysconfdir ;;
|
|
-sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
|
|
| --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
|
|
sysconfdir=$ac_optarg ;;
|
|
|
|
-target | --target | --targe | --targ | --tar | --ta | --t)
|
|
ac_prev=target_alias ;;
|
|
-target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
|
|
target_alias=$ac_optarg ;;
|
|
|
|
-v | -verbose | --verbose | --verbos | --verbo | --verb)
|
|
verbose=yes ;;
|
|
|
|
-version | --version | --versio | --versi | --vers | -V)
|
|
ac_init_version=: ;;
|
|
|
|
-with-* | --with-*)
|
|
ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
|
|
# Reject names that are not valid shell variable names.
|
|
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
|
|
as_fn_error $? "invalid package name: $ac_useropt"
|
|
ac_useropt_orig=$ac_useropt
|
|
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
|
|
case $ac_user_opts in
|
|
*"
|
|
"with_$ac_useropt"
|
|
"*) ;;
|
|
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
|
|
ac_unrecognized_sep=', ';;
|
|
esac
|
|
eval with_$ac_useropt=\$ac_optarg ;;
|
|
|
|
-without-* | --without-*)
|
|
ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
|
|
# Reject names that are not valid shell variable names.
|
|
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
|
|
as_fn_error $? "invalid package name: $ac_useropt"
|
|
ac_useropt_orig=$ac_useropt
|
|
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
|
|
case $ac_user_opts in
|
|
*"
|
|
"with_$ac_useropt"
|
|
"*) ;;
|
|
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
|
|
ac_unrecognized_sep=', ';;
|
|
esac
|
|
eval with_$ac_useropt=no ;;
|
|
|
|
--x)
|
|
# Obsolete; use --with-x.
|
|
with_x=yes ;;
|
|
|
|
-x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
|
|
| --x-incl | --x-inc | --x-in | --x-i)
|
|
ac_prev=x_includes ;;
|
|
-x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
|
|
| --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
|
|
x_includes=$ac_optarg ;;
|
|
|
|
-x-libraries | --x-libraries | --x-librarie | --x-librari \
|
|
| --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
|
|
ac_prev=x_libraries ;;
|
|
-x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
|
|
| --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
|
|
x_libraries=$ac_optarg ;;
|
|
|
|
-*) as_fn_error $? "unrecognized option: \`$ac_option'
|
|
Try \`$0 --help' for more information"
|
|
;;
|
|
|
|
*=*)
|
|
ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
|
|
# Reject names that are not valid shell variable names.
|
|
case $ac_envvar in #(
|
|
'' | [0-9]* | *[!_$as_cr_alnum]* )
|
|
as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
|
|
esac
|
|
eval $ac_envvar=\$ac_optarg
|
|
export $ac_envvar ;;
|
|
|
|
*)
|
|
# FIXME: should be removed in autoconf 3.0.
|
|
$as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
|
|
expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
|
|
$as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
|
|
: "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
|
|
;;
|
|
|
|
esac
|
|
done
|
|
|
|
if test -n "$ac_prev"; then
|
|
ac_option=--`echo $ac_prev | sed 's/_/-/g'`
|
|
as_fn_error $? "missing argument to $ac_option"
|
|
fi
|
|
|
|
if test -n "$ac_unrecognized_opts"; then
|
|
case $enable_option_checking in
|
|
no) ;;
|
|
fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
|
|
*) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
|
|
esac
|
|
fi
|
|
|
|
# Check all directory arguments for consistency.
|
|
for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
|
|
datadir sysconfdir sharedstatedir localstatedir includedir \
|
|
oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
|
|
libdir localedir mandir
|
|
do
|
|
eval ac_val=\$$ac_var
|
|
# Remove trailing slashes.
|
|
case $ac_val in
|
|
*/ )
|
|
ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
|
|
eval $ac_var=\$ac_val;;
|
|
esac
|
|
# Be sure to have absolute directory names.
|
|
case $ac_val in
|
|
[\\/$]* | ?:[\\/]* ) continue;;
|
|
NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
|
|
esac
|
|
as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
|
|
done
|
|
|
|
# There might be people who depend on the old broken behavior: `$host'
|
|
# used to hold the argument of --host etc.
|
|
# FIXME: To remove some day.
|
|
build=$build_alias
|
|
host=$host_alias
|
|
target=$target_alias
|
|
|
|
# FIXME: To remove some day.
|
|
if test "x$host_alias" != x; then
|
|
if test "x$build_alias" = x; then
|
|
cross_compiling=maybe
|
|
elif test "x$build_alias" != "x$host_alias"; then
|
|
cross_compiling=yes
|
|
fi
|
|
fi
|
|
|
|
ac_tool_prefix=
|
|
test -n "$host_alias" && ac_tool_prefix=$host_alias-
|
|
|
|
test "$silent" = yes && exec 6>/dev/null
|
|
|
|
|
|
ac_pwd=`pwd` && test -n "$ac_pwd" &&
|
|
ac_ls_di=`ls -di .` &&
|
|
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
|
|
as_fn_error $? "working directory cannot be determined"
|
|
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
|
|
as_fn_error $? "pwd does not report name of working directory"
|
|
|
|
|
|
# Find the source files, if location was not specified.
|
|
if test -z "$srcdir"; then
|
|
ac_srcdir_defaulted=yes
|
|
# Try the directory containing this script, then the parent directory.
|
|
ac_confdir=`$as_dirname -- "$as_myself" ||
|
|
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
|
|
X"$as_myself" : 'X\(//\)[^/]' \| \
|
|
X"$as_myself" : 'X\(//\)$' \| \
|
|
X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
|
|
$as_echo X"$as_myself" |
|
|
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)[^/].*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q'`
|
|
srcdir=$ac_confdir
|
|
if test ! -r "$srcdir/$ac_unique_file"; then
|
|
srcdir=..
|
|
fi
|
|
else
|
|
ac_srcdir_defaulted=no
|
|
fi
|
|
if test ! -r "$srcdir/$ac_unique_file"; then
|
|
test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
|
|
as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
|
|
fi
|
|
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
|
|
ac_abs_confdir=`(
|
|
cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
|
|
pwd)`
|
|
# When building in place, set srcdir=.
|
|
if test "$ac_abs_confdir" = "$ac_pwd"; then
|
|
srcdir=.
|
|
fi
|
|
# Remove unnecessary trailing slashes from srcdir.
|
|
# Double slashes in file names in object file debugging info
|
|
# mess up M-x gdb in Emacs.
|
|
case $srcdir in
|
|
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
|
|
esac
|
|
for ac_var in $ac_precious_vars; do
|
|
eval ac_env_${ac_var}_set=\${${ac_var}+set}
|
|
eval ac_env_${ac_var}_value=\$${ac_var}
|
|
eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
|
|
eval ac_cv_env_${ac_var}_value=\$${ac_var}
|
|
done
|
|
|
|
#
|
|
# Report the --help message.
|
|
#
|
|
if test "$ac_init_help" = "long"; then
|
|
# Omit some internal or obsolete options to make the list less imposing.
|
|
# This message is too long to be a string in the A/UX 3.1 sh.
|
|
cat <<_ACEOF
|
|
\`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
|
|
|
|
Usage: $0 [OPTION]... [VAR=VALUE]...
|
|
|
|
To assign environment variables (e.g., CC, CFLAGS...), specify them as
|
|
VAR=VALUE. See below for descriptions of some of the useful variables.
|
|
|
|
Defaults for the options are specified in brackets.
|
|
|
|
Configuration:
|
|
-h, --help display this help and exit
|
|
--help=short display options specific to this package
|
|
--help=recursive display the short help of all the included packages
|
|
-V, --version display version information and exit
|
|
-q, --quiet, --silent do not print \`checking ...' messages
|
|
--cache-file=FILE cache test results in FILE [disabled]
|
|
-C, --config-cache alias for \`--cache-file=config.cache'
|
|
-n, --no-create do not create output files
|
|
--srcdir=DIR find the sources in DIR [configure dir or \`..']
|
|
|
|
Installation directories:
|
|
--prefix=PREFIX install architecture-independent files in PREFIX
|
|
[$ac_default_prefix]
|
|
--exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
|
|
[PREFIX]
|
|
|
|
By default, \`make install' will install all the files in
|
|
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
|
|
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
|
|
for instance \`--prefix=\$HOME'.
|
|
|
|
For better control, use the options below.
|
|
|
|
Fine tuning of the installation directories:
|
|
--bindir=DIR user executables [EPREFIX/bin]
|
|
--sbindir=DIR system admin executables [EPREFIX/sbin]
|
|
--libexecdir=DIR program executables [EPREFIX/libexec]
|
|
--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
|
|
--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
|
|
--localstatedir=DIR modifiable single-machine data [PREFIX/var]
|
|
--libdir=DIR object code libraries [EPREFIX/lib]
|
|
--includedir=DIR C header files [PREFIX/include]
|
|
--oldincludedir=DIR C header files for non-gcc [/usr/include]
|
|
--datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
|
|
--datadir=DIR read-only architecture-independent data [DATAROOTDIR]
|
|
--infodir=DIR info documentation [DATAROOTDIR/info]
|
|
--localedir=DIR locale-dependent data [DATAROOTDIR/locale]
|
|
--mandir=DIR man documentation [DATAROOTDIR/man]
|
|
--docdir=DIR documentation root [DATAROOTDIR/doc/openjdk]
|
|
--htmldir=DIR html documentation [DOCDIR]
|
|
--dvidir=DIR dvi documentation [DOCDIR]
|
|
--pdfdir=DIR pdf documentation [DOCDIR]
|
|
--psdir=DIR ps documentation [DOCDIR]
|
|
_ACEOF
|
|
|
|
cat <<\_ACEOF
|
|
|
|
X features:
|
|
--x-includes=DIR X include files are in DIR
|
|
--x-libraries=DIR X library files are in DIR
|
|
|
|
System types:
|
|
--build=BUILD configure for building on BUILD [guessed]
|
|
--host=HOST cross-compile to build programs to run on HOST [BUILD]
|
|
--target=TARGET configure for building compilers for TARGET [HOST]
|
|
_ACEOF
|
|
fi
|
|
|
|
if test -n "$ac_init_help"; then
|
|
case $ac_init_help in
|
|
short | recursive ) echo "Configuration of OpenJDK jdk9:";;
|
|
esac
|
|
cat <<\_ACEOF
|
|
|
|
Optional Features:
|
|
--disable-option-checking ignore unrecognized --enable/--with options
|
|
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
|
|
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
|
|
--enable-openjdk-only suppress building custom source even if present
|
|
[disabled]
|
|
--enable-debug set the debug level to fastdebug (shorthand for
|
|
--with-debug-level=fastdebug) [disabled]
|
|
--enable-headless-only only build headless (no GUI) support [disabled]
|
|
--enable-full-docs build complete documentation [enabled if all tools
|
|
found]
|
|
--disable-unlimited-crypto
|
|
Disable unlimited crypto policy [enabled]
|
|
--disable-keep-packaged-modules
|
|
Do not keep packaged modules in jdk image [enable]
|
|
--enable-static-build enable static library build [disabled]
|
|
--disable-warnings-as-errors
|
|
do not consider native warnings to be an error
|
|
[enabled]
|
|
--enable-debug-symbols Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--enable-zip-debug-info Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--enable-native-coverage
|
|
enable native compilation with code coverage
|
|
data[disabled]
|
|
--enable-dtrace[=yes/no/auto]
|
|
enable dtrace. Default is auto, where dtrace is
|
|
enabled if all dependencies are present.
|
|
--enable-aot[=yes/no/auto]
|
|
enable ahead of time compilation feature. Default is
|
|
auto, where aot is enabled if all dependencies are
|
|
present.
|
|
--enable-cds[=yes/no] enable class data sharing feature in non-minimal VM.
|
|
Default is yes.
|
|
--disable-hotspot-gtest Disables building of the Hotspot unit tests
|
|
--disable-freetype-bundling
|
|
disable bundling of the freetype library with the
|
|
build result [enabled on Windows or when using
|
|
--with-freetype, disabled otherwise]
|
|
--enable-libffi-bundling
|
|
enable bundling of libffi.so to make the built JDK
|
|
runnable on more systems
|
|
--enable-jtreg-failure-handler
|
|
forces build of the jtreg failure handler to be
|
|
enabled, missing dependencies become fatal errors.
|
|
Default is auto, where the failure handler is built
|
|
if all dependencies are present and otherwise just
|
|
disabled.
|
|
--disable-generate-classlist
|
|
forces enabling or disabling of the generation of a
|
|
CDS classlist at build time. Default is to generate
|
|
it when either the server or client JVMs are built
|
|
and enable-cds is true.
|
|
--enable-sjavac use sjavac to do fast incremental compiles
|
|
[disabled]
|
|
--disable-javac-server disable javac server [enabled]
|
|
--enable-icecc enable distribted compilation of native code using
|
|
icecc/icecream [disabled]
|
|
--disable-precompiled-headers
|
|
disable using precompiled headers when compiling C++
|
|
[enabled]
|
|
--enable-ccache enable using ccache to speed up recompilations
|
|
[disabled]
|
|
|
|
Optional Packages:
|
|
--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
|
|
--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
|
|
--with-target-bits build 32-bit or 64-bit binaries (for platforms that
|
|
support it), e.g. --with-target-bits=32 [guessed]
|
|
--with-custom-make-dir Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-jdk-variant JDK variant to build (normal) [normal]
|
|
--with-debug-level set the debug level (release, fastdebug, slowdebug,
|
|
optimized) [release]
|
|
--with-jvm-variants JVM variants (separated by commas) to build
|
|
(server,client,minimal,core,zero,zeroshark,custom)
|
|
[server]
|
|
--with-cpu-port specify sources to use for Hotspot 64-bit ARM port
|
|
(arm64,aarch64) [aarch64]
|
|
--with-devkit use this devkit for compilers, tools and resources
|
|
--with-sys-root alias for --with-sysroot for backwards compatability
|
|
--with-sysroot use this directory as sysroot
|
|
--with-tools-dir alias for --with-toolchain-path for backwards
|
|
compatibility
|
|
--with-toolchain-path prepend these directories when searching for
|
|
toolchain binaries (compilers etc)
|
|
--with-extra-path prepend these directories to the default path
|
|
--with-sdk-name use the platform SDK of the given name. [macosx]
|
|
--with-conf-name use this as the name of the configuration [generated
|
|
from important configuration options]
|
|
--with-output-sync set make output sync type if supported by make.
|
|
[recurse]
|
|
--with-default-make-target
|
|
set the default make target [exploded-image]
|
|
--with-cacerts-file specify alternative cacerts file
|
|
--with-copyright-year Set copyright year value for build [current year]
|
|
--with-milestone Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-update-version Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-user-release-suffix
|
|
Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-build-number Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-version-string Set version string [calculated]
|
|
--with-version-pre Set the base part of the version 'PRE' field
|
|
(pre-release identifier) ['internal']
|
|
--with-version-opt Set version 'OPT' field (build metadata)
|
|
[<timestamp>.<user>.<dirname>]
|
|
--with-version-build Set version 'BUILD' field (build number) [not
|
|
specified]
|
|
--with-version-major Set version 'MAJOR' field (first number) [current
|
|
source value]
|
|
--with-version-minor Set version 'MINOR' field (second number) [current
|
|
source value]
|
|
--with-version-security Set version 'SECURITY' field (third number) [current
|
|
source value]
|
|
--with-version-patch Set version 'PATCH' field (fourth number) [not
|
|
specified]
|
|
--with-boot-jdk path to Boot JDK (used to bootstrap build) [probed]
|
|
--with-build-jdk path to JDK of same version as is being built[the
|
|
newly built JDK]
|
|
--with-add-source-root Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-source-root
|
|
Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-adds-and-overrides
|
|
Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-langtools
|
|
Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-corba Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-jaxp Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-jaxws Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-hotspot Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-nashorn Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-override-jdk Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-import_hotspot Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-import-modules import a set of prebuilt modules either as a zip
|
|
file or an exploded directory
|
|
--with-toolchain-type the toolchain type (or family) to use, use '--help'
|
|
to show possible values [platform dependent]
|
|
--with-extra-cflags extra flags to be used when compiling jdk c-files
|
|
--with-extra-cxxflags extra flags to be used when compiling jdk c++-files
|
|
--with-extra-ldflags extra flags to be used when linking jdk
|
|
--with-toolchain-version
|
|
the version of the toolchain to look for, use
|
|
'--help' to show possible values [platform
|
|
dependent]
|
|
--with-build-devkit Devkit to use for the build platform toolchain
|
|
--with-jtreg Regression Test Harness [probed]
|
|
--with-jib Jib dependency management tool [not used]
|
|
--with-abi-profile specify ABI profile for ARM builds
|
|
(arm-vfp-sflt,arm-vfp-hflt,arm-sflt,
|
|
armv5-vfp-sflt,armv6-vfp-hflt,arm64,aarch64)
|
|
[toolchain dependent]
|
|
--with-macosx-version-max
|
|
error on use of newer functionality. [macosx]
|
|
--with-native-debug-symbols
|
|
set the native debug symbol configuration (none,
|
|
internal, external, zipped) [varying]
|
|
--with-stdc++lib=<static>,<dynamic>,<default>
|
|
force linking of the C++ runtime on Linux to either
|
|
static or dynamic, default is static with dynamic as
|
|
fallback
|
|
--with-msvcr-dll path to microsoft C runtime dll (msvcr*.dll)
|
|
(Windows only) [probed]
|
|
--with-msvcp-dll path to microsoft C++ runtime dll (msvcp*.dll)
|
|
(Windows only) [probed]
|
|
--with-x use the X Window System
|
|
--with-cups specify prefix directory for the cups package
|
|
(expecting the headers under PATH/include)
|
|
--with-cups-include specify directory for the cups include files
|
|
--with-freetype specify prefix directory for the freetype package
|
|
(expecting the libraries under PATH/lib and the
|
|
headers under PATH/include)
|
|
--with-freetype-include specify directory for the freetype include files
|
|
--with-freetype-lib specify directory for the freetype library
|
|
--with-freetype-src specify directory with freetype sources to
|
|
automatically build the library (experimental,
|
|
Windows-only)
|
|
--with-freetype-license if bundling freetype, also bundle this license file
|
|
--with-alsa specify prefix directory for the alsa package
|
|
(expecting the libraries under PATH/lib and the
|
|
headers under PATH/include)
|
|
--with-alsa-include specify directory for the alsa include files
|
|
--with-alsa-lib specify directory for the alsa library
|
|
--with-libffi specify prefix directory for the libffi package
|
|
(expecting the libraries under PATH/lib and the
|
|
headers under PATH/include)
|
|
--with-libffi-include specify directory for the libffi include files
|
|
--with-libffi-lib specify directory for the libffi library
|
|
--with-libjpeg use libjpeg from build system or OpenJDK source
|
|
(system, bundled) [bundled]
|
|
--with-giflib use giflib from build system or OpenJDK source
|
|
(system, bundled) [bundled]
|
|
--with-libpng use libpng from build system or OpenJDK source
|
|
(system, bundled) [bundled]
|
|
--with-zlib use zlib from build system or OpenJDK source
|
|
(system, bundled) [bundled]
|
|
--with-lcms use lcms2 from build system or OpenJDK source
|
|
(system, bundled) [bundled]
|
|
--with-dxsdk Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-dxsdk-lib Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-dxsdk-include Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-jvm-features additional JVM features to enable (separated by
|
|
comma), use '--help' to show possible values [none]
|
|
--with-jvm-interpreter Deprecated. Option is kept for backwards
|
|
compatibility and is ignored
|
|
--with-num-cores number of cores in the build system, e.g.
|
|
--with-num-cores=8 [probed]
|
|
--with-memory-size memory (in MB) available in the build system, e.g.
|
|
--with-memory-size=1024 [probed]
|
|
--with-jobs number of parallel jobs to let make run [calculated
|
|
based on cores and memory]
|
|
--with-test-jobs number of parallel tests jobs to run [based on build
|
|
jobs]
|
|
--with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
|
|
invocations of boot JDK, overriding the default
|
|
values, e.g --with-boot-jdk-jvmargs="-Xmx8G
|
|
-enableassertions"
|
|
--with-sjavac-server-java
|
|
use this java binary for running the sjavac
|
|
background server [Boot JDK java]
|
|
--with-ccache-dir where to store ccache files [~/.ccache]
|
|
|
|
Some influential environment variables:
|
|
BASENAME Override default value for BASENAME
|
|
BASH Override default value for BASH
|
|
CAT Override default value for CAT
|
|
CHMOD Override default value for CHMOD
|
|
CMP Override default value for CMP
|
|
COMM Override default value for COMM
|
|
CP Override default value for CP
|
|
CUT Override default value for CUT
|
|
DATE Override default value for DATE
|
|
DIFF Override default value for DIFF
|
|
DIRNAME Override default value for DIRNAME
|
|
ECHO Override default value for ECHO
|
|
EXPR Override default value for EXPR
|
|
FILE Override default value for FILE
|
|
FIND Override default value for FIND
|
|
HEAD Override default value for HEAD
|
|
GUNZIP Override default value for GUNZIP
|
|
GZIP Override default value for GZIP
|
|
LN Override default value for LN
|
|
LS Override default value for LS
|
|
MKDIR Override default value for MKDIR
|
|
MKTEMP Override default value for MKTEMP
|
|
MV Override default value for MV
|
|
NAWK Override default value for NAWK
|
|
PRINTF Override default value for PRINTF
|
|
RM Override default value for RM
|
|
RMDIR Override default value for RMDIR
|
|
SH Override default value for SH
|
|
SORT Override default value for SORT
|
|
TAIL Override default value for TAIL
|
|
TAR Override default value for TAR
|
|
TEE Override default value for TEE
|
|
TOUCH Override default value for TOUCH
|
|
TR Override default value for TR
|
|
UNAME Override default value for UNAME
|
|
UNIQ Override default value for UNIQ
|
|
WC Override default value for WC
|
|
WHICH Override default value for WHICH
|
|
XARGS Override default value for XARGS
|
|
AWK Override default value for AWK
|
|
GREP Override default value for GREP
|
|
EGREP Override default value for EGREP
|
|
FGREP Override default value for FGREP
|
|
SED Override default value for SED
|
|
CYGPATH Override default value for CYGPATH
|
|
READLINK Override default value for READLINK
|
|
DF Override default value for DF
|
|
CPIO Override default value for CPIO
|
|
NICE Override default value for NICE
|
|
PANDOC Override default value for PANDOC
|
|
MAKE Override default value for MAKE
|
|
UNZIP Override default value for UNZIP
|
|
ZIPEXE Override default value for ZIPEXE
|
|
LDD Override default value for LDD
|
|
OTOOL Override default value for OTOOL
|
|
READELF Override default value for READELF
|
|
DOT Override default value for DOT
|
|
HG Override default value for HG
|
|
STAT Override default value for STAT
|
|
TIME Override default value for TIME
|
|
FLOCK Override default value for FLOCK
|
|
DTRACE Override default value for DTRACE
|
|
PATCH Override default value for PATCH
|
|
DSYMUTIL Override default value for DSYMUTIL
|
|
XATTR Override default value for XATTR
|
|
CODESIGN Override default value for CODESIGN
|
|
SETFILE Override default value for SETFILE
|
|
PKG_CONFIG path to pkg-config utility
|
|
JAVA Override default value for JAVA
|
|
JAVAC Override default value for JAVAC
|
|
JAVAH Override default value for JAVAH
|
|
JAR Override default value for JAR
|
|
JARSIGNER Override default value for JARSIGNER
|
|
CC C compiler command
|
|
CFLAGS C compiler flags
|
|
LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
|
|
nonstandard directory <lib dir>
|
|
LIBS libraries to pass to the linker, e.g. -l<library>
|
|
CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
|
|
you have headers in a nonstandard directory <include dir>
|
|
CXX C++ compiler command
|
|
CXXFLAGS C++ compiler flags
|
|
CPP C preprocessor
|
|
CXXCPP C++ preprocessor
|
|
AS Override default value for AS
|
|
AR Override default value for AR
|
|
LIPO Override default value for LIPO
|
|
STRIP Override default value for STRIP
|
|
NM Override default value for NM
|
|
GNM Override default value for GNM
|
|
OBJCOPY Override default value for OBJCOPY
|
|
OBJDUMP Override default value for OBJDUMP
|
|
BUILD_CC Override default value for BUILD_CC
|
|
BUILD_CXX Override default value for BUILD_CXX
|
|
BUILD_NM Override default value for BUILD_NM
|
|
BUILD_AR Override default value for BUILD_AR
|
|
BUILD_OBJCOPY
|
|
Override default value for BUILD_OBJCOPY
|
|
BUILD_STRIP Override default value for BUILD_STRIP
|
|
JTREGEXE Override default value for JTREGEXE
|
|
XMKMF Path to xmkmf, Makefile generator for X Window System
|
|
FREETYPE_CFLAGS
|
|
C compiler flags for FREETYPE, overriding pkg-config
|
|
FREETYPE_LIBS
|
|
linker flags for FREETYPE, overriding pkg-config
|
|
ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
|
|
ALSA_LIBS linker flags for ALSA, overriding pkg-config
|
|
LIBFFI_CFLAGS
|
|
C compiler flags for LIBFFI, overriding pkg-config
|
|
LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
|
|
PNG_CFLAGS C compiler flags for PNG, overriding pkg-config
|
|
PNG_LIBS linker flags for PNG, overriding pkg-config
|
|
LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
|
|
LCMS_LIBS linker flags for LCMS, overriding pkg-config
|
|
ICECC_CMD Override default value for ICECC_CMD
|
|
ICECC_CREATE_ENV
|
|
Override default value for ICECC_CREATE_ENV
|
|
ICECC_WRAPPER
|
|
Override default value for ICECC_WRAPPER
|
|
CCACHE Override default value for CCACHE
|
|
|
|
Use these variables to override the choices made by `configure' or to help
|
|
it to find libraries and programs with nonstandard names/locations.
|
|
|
|
Report bugs to <build-dev@openjdk.java.net>.
|
|
OpenJDK home page: <http://openjdk.java.net>.
|
|
_ACEOF
|
|
ac_status=$?
|
|
fi
|
|
|
|
if test "$ac_init_help" = "recursive"; then
|
|
# If there are subdirs, report their specific --help.
|
|
for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
|
|
test -d "$ac_dir" ||
|
|
{ cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
|
|
continue
|
|
ac_builddir=.
|
|
|
|
case "$ac_dir" in
|
|
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
|
|
*)
|
|
ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
|
|
# A ".." for each directory in $ac_dir_suffix.
|
|
ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
|
|
case $ac_top_builddir_sub in
|
|
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
|
|
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
|
|
esac ;;
|
|
esac
|
|
ac_abs_top_builddir=$ac_pwd
|
|
ac_abs_builddir=$ac_pwd$ac_dir_suffix
|
|
# for backward compatibility:
|
|
ac_top_builddir=$ac_top_build_prefix
|
|
|
|
case $srcdir in
|
|
.) # We are building in place.
|
|
ac_srcdir=.
|
|
ac_top_srcdir=$ac_top_builddir_sub
|
|
ac_abs_top_srcdir=$ac_pwd ;;
|
|
[\\/]* | ?:[\\/]* ) # Absolute name.
|
|
ac_srcdir=$srcdir$ac_dir_suffix;
|
|
ac_top_srcdir=$srcdir
|
|
ac_abs_top_srcdir=$srcdir ;;
|
|
*) # Relative name.
|
|
ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
|
|
ac_top_srcdir=$ac_top_build_prefix$srcdir
|
|
ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
|
|
esac
|
|
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
|
|
|
|
cd "$ac_dir" || { ac_status=$?; continue; }
|
|
# Check for guested configure.
|
|
if test -f "$ac_srcdir/configure.gnu"; then
|
|
echo &&
|
|
$SHELL "$ac_srcdir/configure.gnu" --help=recursive
|
|
elif test -f "$ac_srcdir/configure"; then
|
|
echo &&
|
|
$SHELL "$ac_srcdir/configure" --help=recursive
|
|
else
|
|
$as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
|
|
fi || ac_status=$?
|
|
cd "$ac_pwd" || { ac_status=$?; break; }
|
|
done
|
|
fi
|
|
|
|
test -n "$ac_init_help" && exit $ac_status
|
|
if $ac_init_version; then
|
|
cat <<\_ACEOF
|
|
OpenJDK configure jdk9
|
|
generated by GNU Autoconf 2.69
|
|
|
|
Copyright (C) 2012 Free Software Foundation, Inc.
|
|
This configure script is free software; the Free Software Foundation
|
|
gives unlimited permission to copy, distribute and modify it.
|
|
_ACEOF
|
|
exit
|
|
fi
|
|
|
|
## ------------------------ ##
|
|
## Autoconf initialization. ##
|
|
## ------------------------ ##
|
|
|
|
# ac_fn_c_try_compile LINENO
|
|
# --------------------------
|
|
# Try to compile conftest.$ac_ext, and return whether this succeeded.
|
|
ac_fn_c_try_compile ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
rm -f conftest.$ac_objext
|
|
if { { ac_try="$ac_compile"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_compile") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
grep -v '^ *+' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
mv -f conftest.er1 conftest.err
|
|
fi
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } && {
|
|
test -z "$ac_c_werror_flag" ||
|
|
test ! -s conftest.err
|
|
} && test -s conftest.$ac_objext; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=1
|
|
fi
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_c_try_compile
|
|
|
|
# ac_fn_cxx_try_compile LINENO
|
|
# ----------------------------
|
|
# Try to compile conftest.$ac_ext, and return whether this succeeded.
|
|
ac_fn_cxx_try_compile ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
rm -f conftest.$ac_objext
|
|
if { { ac_try="$ac_compile"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_compile") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
grep -v '^ *+' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
mv -f conftest.er1 conftest.err
|
|
fi
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } && {
|
|
test -z "$ac_cxx_werror_flag" ||
|
|
test ! -s conftest.err
|
|
} && test -s conftest.$ac_objext; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=1
|
|
fi
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_cxx_try_compile
|
|
|
|
# ac_fn_c_try_cpp LINENO
|
|
# ----------------------
|
|
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
|
|
ac_fn_c_try_cpp ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
if { { ac_try="$ac_cpp conftest.$ac_ext"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
grep -v '^ *+' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
mv -f conftest.er1 conftest.err
|
|
fi
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } > conftest.i && {
|
|
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
|
|
test ! -s conftest.err
|
|
}; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=1
|
|
fi
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_c_try_cpp
|
|
|
|
# ac_fn_cxx_try_cpp LINENO
|
|
# ------------------------
|
|
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
|
|
ac_fn_cxx_try_cpp ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
if { { ac_try="$ac_cpp conftest.$ac_ext"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
grep -v '^ *+' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
mv -f conftest.er1 conftest.err
|
|
fi
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } > conftest.i && {
|
|
test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
|
|
test ! -s conftest.err
|
|
}; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=1
|
|
fi
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_cxx_try_cpp
|
|
|
|
# ac_fn_c_try_link LINENO
|
|
# -----------------------
|
|
# Try to link conftest.$ac_ext, and return whether this succeeded.
|
|
ac_fn_c_try_link ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
rm -f conftest.$ac_objext conftest$ac_exeext
|
|
if { { ac_try="$ac_link"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_link") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
grep -v '^ *+' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
mv -f conftest.er1 conftest.err
|
|
fi
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } && {
|
|
test -z "$ac_c_werror_flag" ||
|
|
test ! -s conftest.err
|
|
} && test -s conftest$ac_exeext && {
|
|
test "$cross_compiling" = yes ||
|
|
test -x conftest$ac_exeext
|
|
}; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=1
|
|
fi
|
|
# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
|
|
# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
|
|
# interfere with the next link command; also delete a directory that is
|
|
# left behind by Apple's compiler. We do this before executing the actions.
|
|
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_c_try_link
|
|
|
|
# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
|
|
# ---------------------------------------------------------
|
|
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
|
|
# the include files in INCLUDES and setting the cache variable VAR
|
|
# accordingly.
|
|
ac_fn_cxx_check_header_mongrel ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
if eval \${$3+:} false; then :
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
|
|
$as_echo_n "checking for $2... " >&6; }
|
|
if eval \${$3+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
fi
|
|
eval ac_res=\$$3
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
|
|
$as_echo "$ac_res" >&6; }
|
|
else
|
|
# Is the header compilable?
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
|
|
$as_echo_n "checking $2 usability... " >&6; }
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
#include <$2>
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_header_compiler=yes
|
|
else
|
|
ac_header_compiler=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
|
|
$as_echo "$ac_header_compiler" >&6; }
|
|
|
|
# Is the header present?
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
|
|
$as_echo_n "checking $2 presence... " >&6; }
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <$2>
|
|
_ACEOF
|
|
if ac_fn_cxx_try_cpp "$LINENO"; then :
|
|
ac_header_preproc=yes
|
|
else
|
|
ac_header_preproc=no
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
|
|
$as_echo "$ac_header_preproc" >&6; }
|
|
|
|
# So? What about this header?
|
|
case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
|
|
yes:no: )
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
|
|
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
|
|
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
|
|
;;
|
|
no:yes:* )
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
|
|
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
|
|
$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
|
|
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
|
|
$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
|
|
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
|
|
( $as_echo "## ----------------------------------------- ##
|
|
## Report this to build-dev@openjdk.java.net ##
|
|
## ----------------------------------------- ##"
|
|
) | sed "s/^/$as_me: WARNING: /" >&2
|
|
;;
|
|
esac
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
|
|
$as_echo_n "checking for $2... " >&6; }
|
|
if eval \${$3+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
eval "$3=\$ac_header_compiler"
|
|
fi
|
|
eval ac_res=\$$3
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
|
|
$as_echo "$ac_res" >&6; }
|
|
fi
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
|
|
} # ac_fn_cxx_check_header_mongrel
|
|
|
|
# ac_fn_cxx_try_run LINENO
|
|
# ------------------------
|
|
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
|
|
# that executables *can* be run.
|
|
ac_fn_cxx_try_run ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
if { { ac_try="$ac_link"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_link") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
|
|
{ { case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_try") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; }; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: program exited with status $ac_status" >&5
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=$ac_status
|
|
fi
|
|
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_cxx_try_run
|
|
|
|
# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
|
|
# ---------------------------------------------------------
|
|
# Tests whether HEADER exists and can be compiled using the include files in
|
|
# INCLUDES, setting the cache variable VAR accordingly.
|
|
ac_fn_cxx_check_header_compile ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
|
|
$as_echo_n "checking for $2... " >&6; }
|
|
if eval \${$3+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
#include <$2>
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
eval "$3=yes"
|
|
else
|
|
eval "$3=no"
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
eval ac_res=\$$3
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
|
|
$as_echo "$ac_res" >&6; }
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
|
|
} # ac_fn_cxx_check_header_compile
|
|
|
|
# ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
|
|
# ----------------------------------------------
|
|
# Tries to find the compile-time value of EXPR in a program that includes
|
|
# INCLUDES, setting VAR accordingly. Returns whether the value could be
|
|
# computed
|
|
ac_fn_cxx_compute_int ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
if test "$cross_compiling" = yes; then
|
|
# Depending upon the size, compute the lo and hi bounds.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
int
|
|
main ()
|
|
{
|
|
static int test_array [1 - 2 * !(($2) >= 0)];
|
|
test_array [0] = 0;
|
|
return test_array [0];
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_lo=0 ac_mid=0
|
|
while :; do
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
int
|
|
main ()
|
|
{
|
|
static int test_array [1 - 2 * !(($2) <= $ac_mid)];
|
|
test_array [0] = 0;
|
|
return test_array [0];
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_hi=$ac_mid; break
|
|
else
|
|
as_fn_arith $ac_mid + 1 && ac_lo=$as_val
|
|
if test $ac_lo -le $ac_mid; then
|
|
ac_lo= ac_hi=
|
|
break
|
|
fi
|
|
as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
done
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
int
|
|
main ()
|
|
{
|
|
static int test_array [1 - 2 * !(($2) < 0)];
|
|
test_array [0] = 0;
|
|
return test_array [0];
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_hi=-1 ac_mid=-1
|
|
while :; do
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
int
|
|
main ()
|
|
{
|
|
static int test_array [1 - 2 * !(($2) >= $ac_mid)];
|
|
test_array [0] = 0;
|
|
return test_array [0];
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_lo=$ac_mid; break
|
|
else
|
|
as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
|
|
if test $ac_mid -le $ac_hi; then
|
|
ac_lo= ac_hi=
|
|
break
|
|
fi
|
|
as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
done
|
|
else
|
|
ac_lo= ac_hi=
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
# Binary search between lo and hi bounds.
|
|
while test "x$ac_lo" != "x$ac_hi"; do
|
|
as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
int
|
|
main ()
|
|
{
|
|
static int test_array [1 - 2 * !(($2) <= $ac_mid)];
|
|
test_array [0] = 0;
|
|
return test_array [0];
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_hi=$ac_mid
|
|
else
|
|
as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
done
|
|
case $ac_lo in #((
|
|
?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
|
|
'') ac_retval=1 ;;
|
|
esac
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
static long int longval () { return $2; }
|
|
static unsigned long int ulongval () { return $2; }
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
int
|
|
main ()
|
|
{
|
|
|
|
FILE *f = fopen ("conftest.val", "w");
|
|
if (! f)
|
|
return 1;
|
|
if (($2) < 0)
|
|
{
|
|
long int i = longval ();
|
|
if (i != ($2))
|
|
return 1;
|
|
fprintf (f, "%ld", i);
|
|
}
|
|
else
|
|
{
|
|
unsigned long int i = ulongval ();
|
|
if (i != ($2))
|
|
return 1;
|
|
fprintf (f, "%lu", i);
|
|
}
|
|
/* Do not output a trailing newline, as this causes \r\n confusion
|
|
on some platforms. */
|
|
return ferror (f) || fclose (f) != 0;
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_run "$LINENO"; then :
|
|
echo >>conftest.val; read $3 <conftest.val; ac_retval=0
|
|
else
|
|
ac_retval=1
|
|
fi
|
|
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
|
|
conftest.$ac_objext conftest.beam conftest.$ac_ext
|
|
rm -f conftest.val
|
|
|
|
fi
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_cxx_compute_int
|
|
|
|
# ac_fn_cxx_try_link LINENO
|
|
# -------------------------
|
|
# Try to link conftest.$ac_ext, and return whether this succeeded.
|
|
ac_fn_cxx_try_link ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
rm -f conftest.$ac_objext conftest$ac_exeext
|
|
if { { ac_try="$ac_link"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_link") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
grep -v '^ *+' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
mv -f conftest.er1 conftest.err
|
|
fi
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; } && {
|
|
test -z "$ac_cxx_werror_flag" ||
|
|
test ! -s conftest.err
|
|
} && test -s conftest$ac_exeext && {
|
|
test "$cross_compiling" = yes ||
|
|
test -x conftest$ac_exeext
|
|
}; then :
|
|
ac_retval=0
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
ac_retval=1
|
|
fi
|
|
# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
|
|
# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
|
|
# interfere with the next link command; also delete a directory that is
|
|
# left behind by Apple's compiler. We do this before executing the actions.
|
|
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
as_fn_set_status $ac_retval
|
|
|
|
} # ac_fn_cxx_try_link
|
|
|
|
# ac_fn_cxx_check_func LINENO FUNC VAR
|
|
# ------------------------------------
|
|
# Tests whether FUNC exists, setting the cache variable VAR accordingly
|
|
ac_fn_cxx_check_func ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
|
|
$as_echo_n "checking for $2... " >&6; }
|
|
if eval \${$3+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
|
|
For example, HP-UX 11i <limits.h> declares gettimeofday. */
|
|
#define $2 innocuous_$2
|
|
|
|
/* System header to define __stub macros and hopefully few prototypes,
|
|
which can conflict with char $2 (); below.
|
|
Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
|
|
<limits.h> exists even on freestanding compilers. */
|
|
|
|
#ifdef __STDC__
|
|
# include <limits.h>
|
|
#else
|
|
# include <assert.h>
|
|
#endif
|
|
|
|
#undef $2
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char $2 ();
|
|
/* The GNU C library defines this for functions which it implements
|
|
to always fail with ENOSYS. Some functions are actually named
|
|
something starting with __ and the normal name is an alias. */
|
|
#if defined __stub_$2 || defined __stub___$2
|
|
choke me
|
|
#endif
|
|
|
|
int
|
|
main ()
|
|
{
|
|
return $2 ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
eval "$3=yes"
|
|
else
|
|
eval "$3=no"
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
fi
|
|
eval ac_res=\$$3
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
|
|
$as_echo "$ac_res" >&6; }
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
|
|
} # ac_fn_cxx_check_func
|
|
|
|
# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
|
|
# -------------------------------------------------------
|
|
# Tests whether HEADER exists and can be compiled using the include files in
|
|
# INCLUDES, setting the cache variable VAR accordingly.
|
|
ac_fn_c_check_header_compile ()
|
|
{
|
|
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
|
|
$as_echo_n "checking for $2... " >&6; }
|
|
if eval \${$3+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$4
|
|
#include <$2>
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
eval "$3=yes"
|
|
else
|
|
eval "$3=no"
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
eval ac_res=\$$3
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
|
|
$as_echo "$ac_res" >&6; }
|
|
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
|
|
|
|
} # ac_fn_c_check_header_compile
|
|
cat >config.log <<_ACEOF
|
|
This file contains any messages produced by compilers while
|
|
running configure, to aid debugging if configure makes a mistake.
|
|
|
|
It was created by OpenJDK $as_me jdk9, which was
|
|
generated by GNU Autoconf 2.69. Invocation command line was
|
|
|
|
$ $0 $@
|
|
|
|
_ACEOF
|
|
exec 5>>config.log
|
|
{
|
|
cat <<_ASUNAME
|
|
## --------- ##
|
|
## Platform. ##
|
|
## --------- ##
|
|
|
|
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
|
|
uname -m = `(uname -m) 2>/dev/null || echo unknown`
|
|
uname -r = `(uname -r) 2>/dev/null || echo unknown`
|
|
uname -s = `(uname -s) 2>/dev/null || echo unknown`
|
|
uname -v = `(uname -v) 2>/dev/null || echo unknown`
|
|
|
|
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
|
|
/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
|
|
|
|
/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
|
|
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
|
|
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
|
|
/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
|
|
/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
|
|
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
|
|
/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
|
|
|
|
_ASUNAME
|
|
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
$as_echo "PATH: $as_dir"
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
} >&5
|
|
|
|
cat >&5 <<_ACEOF
|
|
|
|
|
|
## ----------- ##
|
|
## Core tests. ##
|
|
## ----------- ##
|
|
|
|
_ACEOF
|
|
|
|
|
|
# Keep a trace of the command line.
|
|
# Strip out --no-create and --no-recursion so they do not pile up.
|
|
# Strip out --silent because we don't want to record it for future runs.
|
|
# Also quote any args containing shell meta-characters.
|
|
# Make two passes to allow for proper duplicate-argument suppression.
|
|
ac_configure_args=
|
|
ac_configure_args0=
|
|
ac_configure_args1=
|
|
ac_must_keep_next=false
|
|
for ac_pass in 1 2
|
|
do
|
|
for ac_arg
|
|
do
|
|
case $ac_arg in
|
|
-no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
|
|
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
|
|
| -silent | --silent | --silen | --sile | --sil)
|
|
continue ;;
|
|
*\'*)
|
|
ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
|
|
esac
|
|
case $ac_pass in
|
|
1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
|
|
2)
|
|
as_fn_append ac_configure_args1 " '$ac_arg'"
|
|
if test $ac_must_keep_next = true; then
|
|
ac_must_keep_next=false # Got value, back to normal.
|
|
else
|
|
case $ac_arg in
|
|
*=* | --config-cache | -C | -disable-* | --disable-* \
|
|
| -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
|
|
| -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
|
|
| -with-* | --with-* | -without-* | --without-* | --x)
|
|
case "$ac_configure_args0 " in
|
|
"$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
|
|
esac
|
|
;;
|
|
-* ) ac_must_keep_next=true ;;
|
|
esac
|
|
fi
|
|
as_fn_append ac_configure_args " '$ac_arg'"
|
|
;;
|
|
esac
|
|
done
|
|
done
|
|
{ ac_configure_args0=; unset ac_configure_args0;}
|
|
{ ac_configure_args1=; unset ac_configure_args1;}
|
|
|
|
# When interrupted or exit'd, cleanup temporary files, and complete
|
|
# config.log. We remove comments because anyway the quotes in there
|
|
# would cause problems or look ugly.
|
|
# WARNING: Use '\'' to represent an apostrophe within the trap.
|
|
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
|
|
trap 'exit_status=$?
|
|
# Save into config.log some information that might help in debugging.
|
|
{
|
|
echo
|
|
|
|
$as_echo "## ---------------- ##
|
|
## Cache variables. ##
|
|
## ---------------- ##"
|
|
echo
|
|
# The following way of writing the cache mishandles newlines in values,
|
|
(
|
|
for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
|
|
eval ac_val=\$$ac_var
|
|
case $ac_val in #(
|
|
*${as_nl}*)
|
|
case $ac_var in #(
|
|
*_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
|
|
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
|
|
esac
|
|
case $ac_var in #(
|
|
_ | IFS | as_nl) ;; #(
|
|
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
|
|
*) { eval $ac_var=; unset $ac_var;} ;;
|
|
esac ;;
|
|
esac
|
|
done
|
|
(set) 2>&1 |
|
|
case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
|
|
*${as_nl}ac_space=\ *)
|
|
sed -n \
|
|
"s/'\''/'\''\\\\'\'''\''/g;
|
|
s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
|
|
;; #(
|
|
*)
|
|
sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
|
|
;;
|
|
esac |
|
|
sort
|
|
)
|
|
echo
|
|
|
|
$as_echo "## ----------------- ##
|
|
## Output variables. ##
|
|
## ----------------- ##"
|
|
echo
|
|
for ac_var in $ac_subst_vars
|
|
do
|
|
eval ac_val=\$$ac_var
|
|
case $ac_val in
|
|
*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
|
|
esac
|
|
$as_echo "$ac_var='\''$ac_val'\''"
|
|
done | sort
|
|
echo
|
|
|
|
if test -n "$ac_subst_files"; then
|
|
$as_echo "## ------------------- ##
|
|
## File substitutions. ##
|
|
## ------------------- ##"
|
|
echo
|
|
for ac_var in $ac_subst_files
|
|
do
|
|
eval ac_val=\$$ac_var
|
|
case $ac_val in
|
|
*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
|
|
esac
|
|
$as_echo "$ac_var='\''$ac_val'\''"
|
|
done | sort
|
|
echo
|
|
fi
|
|
|
|
if test -s confdefs.h; then
|
|
$as_echo "## ----------- ##
|
|
## confdefs.h. ##
|
|
## ----------- ##"
|
|
echo
|
|
cat confdefs.h
|
|
echo
|
|
fi
|
|
test "$ac_signal" != 0 &&
|
|
$as_echo "$as_me: caught signal $ac_signal"
|
|
$as_echo "$as_me: exit $exit_status"
|
|
} >&5
|
|
rm -f core *.core core.conftest.* &&
|
|
rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
|
|
exit $exit_status
|
|
' 0
|
|
for ac_signal in 1 2 13 15; do
|
|
trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
|
|
done
|
|
ac_signal=0
|
|
|
|
# confdefs.h avoids OS command line length limits that DEFS can exceed.
|
|
rm -f -r conftest* confdefs.h
|
|
|
|
$as_echo "/* confdefs.h */" > confdefs.h
|
|
|
|
# Predefined preprocessor variables.
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define PACKAGE_NAME "$PACKAGE_NAME"
|
|
_ACEOF
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
|
|
_ACEOF
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define PACKAGE_VERSION "$PACKAGE_VERSION"
|
|
_ACEOF
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define PACKAGE_STRING "$PACKAGE_STRING"
|
|
_ACEOF
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
|
|
_ACEOF
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define PACKAGE_URL "$PACKAGE_URL"
|
|
_ACEOF
|
|
|
|
|
|
# Let the site file select an alternate cache file if it wants to.
|
|
# Prefer an explicitly selected file to automatically selected ones.
|
|
ac_site_file1=NONE
|
|
ac_site_file2=NONE
|
|
if test -n "$CONFIG_SITE"; then
|
|
# We do not want a PATH search for config.site.
|
|
case $CONFIG_SITE in #((
|
|
-*) ac_site_file1=./$CONFIG_SITE;;
|
|
*/*) ac_site_file1=$CONFIG_SITE;;
|
|
*) ac_site_file1=./$CONFIG_SITE;;
|
|
esac
|
|
elif test "x$prefix" != xNONE; then
|
|
ac_site_file1=$prefix/share/config.site
|
|
ac_site_file2=$prefix/etc/config.site
|
|
else
|
|
ac_site_file1=$ac_default_prefix/share/config.site
|
|
ac_site_file2=$ac_default_prefix/etc/config.site
|
|
fi
|
|
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
|
|
do
|
|
test "x$ac_site_file" = xNONE && continue
|
|
if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
|
|
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
|
|
sed 's/^/| /' "$ac_site_file" >&5
|
|
. "$ac_site_file" \
|
|
|| { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "failed to load site script $ac_site_file
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
fi
|
|
done
|
|
|
|
if test -r "$cache_file"; then
|
|
# Some versions of bash will fail to source /dev/null (special files
|
|
# actually), so we avoid doing that. DJGPP emulates it as a regular file.
|
|
if test /dev/null != "$cache_file" && test -f "$cache_file"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
|
|
$as_echo "$as_me: loading cache $cache_file" >&6;}
|
|
case $cache_file in
|
|
[\\/]* | ?:[\\/]* ) . "$cache_file";;
|
|
*) . "./$cache_file";;
|
|
esac
|
|
fi
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
|
|
$as_echo "$as_me: creating cache $cache_file" >&6;}
|
|
>$cache_file
|
|
fi
|
|
|
|
# Check that the precious variables saved in the cache have kept the same
|
|
# value.
|
|
ac_cache_corrupted=false
|
|
for ac_var in $ac_precious_vars; do
|
|
eval ac_old_set=\$ac_cv_env_${ac_var}_set
|
|
eval ac_new_set=\$ac_env_${ac_var}_set
|
|
eval ac_old_val=\$ac_cv_env_${ac_var}_value
|
|
eval ac_new_val=\$ac_env_${ac_var}_value
|
|
case $ac_old_set,$ac_new_set in
|
|
set,)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
|
|
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
|
|
ac_cache_corrupted=: ;;
|
|
,set)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
|
|
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
|
|
ac_cache_corrupted=: ;;
|
|
,);;
|
|
*)
|
|
if test "x$ac_old_val" != "x$ac_new_val"; then
|
|
# differences in whitespace do not lead to failure.
|
|
ac_old_val_w=`echo x $ac_old_val`
|
|
ac_new_val_w=`echo x $ac_new_val`
|
|
if test "$ac_old_val_w" != "$ac_new_val_w"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
|
|
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
|
|
ac_cache_corrupted=:
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
|
|
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
|
|
eval $ac_var=\$ac_old_val
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
|
|
$as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
|
|
$as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
|
|
fi;;
|
|
esac
|
|
# Pass precious variables to config.status.
|
|
if test "$ac_new_set" = set; then
|
|
case $ac_new_val in
|
|
*\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
|
|
*) ac_arg=$ac_var=$ac_new_val ;;
|
|
esac
|
|
case " $ac_configure_args " in
|
|
*" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
|
|
*) as_fn_append ac_configure_args " '$ac_arg'" ;;
|
|
esac
|
|
fi
|
|
done
|
|
if $ac_cache_corrupted; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
|
|
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
|
|
as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
|
|
fi
|
|
## -------------------- ##
|
|
## Main body of script. ##
|
|
## -------------------- ##
|
|
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
|
|
|
|
ac_aux_dir=
|
|
for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
|
|
if test -f "$ac_dir/install-sh"; then
|
|
ac_aux_dir=$ac_dir
|
|
ac_install_sh="$ac_aux_dir/install-sh -c"
|
|
break
|
|
elif test -f "$ac_dir/install.sh"; then
|
|
ac_aux_dir=$ac_dir
|
|
ac_install_sh="$ac_aux_dir/install.sh -c"
|
|
break
|
|
elif test -f "$ac_dir/shtool"; then
|
|
ac_aux_dir=$ac_dir
|
|
ac_install_sh="$ac_aux_dir/shtool install -c"
|
|
break
|
|
fi
|
|
done
|
|
if test -z "$ac_aux_dir"; then
|
|
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
|
|
fi
|
|
|
|
# These three variables are undocumented and unsupported,
|
|
# and are intended to be withdrawn in a future Autoconf release.
|
|
# They can cause serious problems if a builder's source tree is in a directory
|
|
# whose full name contains unusual characters.
|
|
ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
|
|
ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
|
|
ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
|
|
|
|
|
|
# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
|
|
|
|
#
|
|
# Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
#
|
|
# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
#
|
|
# As a special exception to the GNU General Public License, if you
|
|
# distribute this file as part of a program that contains a
|
|
# configuration script generated by Autoconf, you may include it under
|
|
# the same distribution terms that you use for the rest of that program.
|
|
|
|
# PKG_PROG_PKG_CONFIG([MIN-VERSION])
|
|
# ----------------------------------
|
|
# PKG_PROG_PKG_CONFIG
|
|
|
|
# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
|
|
#
|
|
# Check to see whether a particular set of modules exists. Similar
|
|
# to PKG_CHECK_MODULES(), but does not set variables or print errors.
|
|
#
|
|
#
|
|
# Similar to PKG_CHECK_MODULES, make sure that the first instance of
|
|
# this or PKG_CHECK_MODULES is called, or make sure to call
|
|
# PKG_CHECK_EXISTS manually
|
|
# --------------------------------------------------------------
|
|
|
|
|
|
|
|
# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
|
|
# ---------------------------------------------
|
|
# _PKG_CONFIG
|
|
|
|
# _PKG_SHORT_ERRORS_SUPPORTED
|
|
# -----------------------------
|
|
# _PKG_SHORT_ERRORS_SUPPORTED
|
|
|
|
|
|
# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
|
|
# [ACTION-IF-NOT-FOUND])
|
|
#
|
|
#
|
|
# Note that if there is a possibility the first call to
|
|
# PKG_CHECK_MODULES might not happen, you should be sure to include an
|
|
# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
|
|
#
|
|
#
|
|
# --------------------------------------------------------------
|
|
# PKG_CHECK_MODULES
|
|
|
|
|
|
# Include these first...
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
# Create a function/macro that takes a series of named arguments. The call is
|
|
# similar to AC_DEFUN, but the setup of the function looks like this:
|
|
# BASIC_DEFUN_NAMED([MYFUNC], [FOO *BAR], [$@], [
|
|
# ... do something
|
|
# AC_MSG_NOTICE([Value of BAR is ARG_BAR])
|
|
# ])
|
|
# A star (*) in front of a named argument means that it is required and it's
|
|
# presence will be verified. To pass e.g. the first value as a normal indexed
|
|
# argument, use [m4_shift($@)] as the third argument instead of [$@]. These
|
|
# arguments are referenced in the function by their name prefixed by ARG_, e.g.
|
|
# "ARG_FOO".
|
|
#
|
|
# The generated function can be called like this:
|
|
# MYFUNC(FOO: [foo-val],
|
|
# BAR: [
|
|
# $ECHO hello world
|
|
# ])
|
|
# Note that the argument value must start on the same line as the argument name.
|
|
#
|
|
# Argument 1: Name of the function to define
|
|
# Argument 2: List of legal named arguments, with a * prefix for required arguments
|
|
# Argument 3: Argument array to treat as named, typically $@
|
|
# Argument 4: The main function body
|
|
|
|
|
|
# Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
|
|
# If so, then append $1 to $2 \
|
|
# Also set JVM_ARG_OK to true/false depending on outcome.
|
|
|
|
|
|
# Appends a string to a path variable, only adding the : when needed.
|
|
|
|
|
|
# Prepends a string to a path variable, only adding the : when needed.
|
|
|
|
|
|
# This will make sure the given variable points to a full and proper
|
|
# path. This means:
|
|
# 1) There will be no spaces in the path. On unix platforms,
|
|
# spaces in the path will result in an error. On Windows,
|
|
# the path will be rewritten using short-style to be space-free.
|
|
# 2) The path will be absolute, and it will be in unix-style (on
|
|
# cygwin).
|
|
# $1: The name of the variable to fix
|
|
|
|
|
|
# This will make sure the given variable points to a executable
|
|
# with a full and proper path. This means:
|
|
# 1) There will be no spaces in the path. On unix platforms,
|
|
# spaces in the path will result in an error. On Windows,
|
|
# the path will be rewritten using short-style to be space-free.
|
|
# 2) The path will be absolute, and it will be in unix-style (on
|
|
# cygwin).
|
|
# Any arguments given to the executable is preserved.
|
|
# If the input variable does not have a directory specification, then
|
|
# it need to be in the PATH.
|
|
# $1: The name of the variable to fix
|
|
|
|
|
|
|
|
|
|
# Register a --with argument but mark it as deprecated
|
|
# $1: The name of the with argument to deprecate, not including --with-
|
|
|
|
|
|
# Register a --enable argument but mark it as deprecated
|
|
# $1: The name of the with argument to deprecate, not including --enable-
|
|
# $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
|
|
# $3: Messages to user.
|
|
|
|
|
|
|
|
|
|
# Test that variable $1 denoting a program is not empty. If empty, exit with an error.
|
|
# $1: variable to check
|
|
|
|
|
|
# Check that there are no unprocessed overridden variables left.
|
|
# If so, they are an incorrect argument and we will exit with an error.
|
|
|
|
|
|
# Setup a tool for the given variable. If correctly specified by the user,
|
|
# use that value, otherwise search for the tool using the supplied code snippet.
|
|
# $1: variable to set
|
|
# $2: code snippet to call to look for the tool
|
|
# $3: code snippet to call if variable was used to find tool
|
|
|
|
|
|
# Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
|
|
# $1: variable to set
|
|
# $2: executable name (or list of names) to look for
|
|
# $3: [path]
|
|
|
|
|
|
# Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
|
|
# $1: variable to set
|
|
# $2: executable name (or list of names) to look for
|
|
|
|
|
|
# Like BASIC_PATH_PROGS but fails if no tool was found.
|
|
# $1: variable to set
|
|
# $2: executable name (or list of names) to look for
|
|
# $3: [path]
|
|
|
|
|
|
# Like BASIC_SETUP_TOOL but fails if no tool was found.
|
|
# $1: variable to set
|
|
# $2: autoconf macro to call to look for the special tool
|
|
|
|
|
|
# Setup the most fundamental tools that relies on not much else to set up,
|
|
# but is used by much of the early bootstrap code.
|
|
|
|
|
|
# Setup basic configuration paths, and platform-specific stuff related to PATHs.
|
|
|
|
|
|
# Evaluates platform specific overrides for devkit variables.
|
|
# $1: Name of variable
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#%%% Simple tools %%%
|
|
|
|
# Check if we have found a usable version of make
|
|
# $1: the path to a potential make binary (or empty)
|
|
# $2: the description on how we found this
|
|
|
|
|
|
|
|
|
|
# Goes looking for a usable version of GNU make.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check if build directory is on local disk. If not possible to determine,
|
|
# we prefer to claim it's local.
|
|
# Argument 1: directory to test
|
|
# Argument 2: what to do if it is on local disk
|
|
# Argument 3: what to do otherwise (remote disk or failure)
|
|
|
|
|
|
# Check that source files have basic read permissions set. This might
|
|
# not be the case in cygwin in certain conditions.
|
|
|
|
|
|
|
|
|
|
# Check for support for specific options in bash
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Default make target
|
|
#
|
|
|
|
|
|
# Code to run after AC_OUTPUT
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
|
|
|
|
|
|
|
|
# Helper function which possibly converts a path using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
# $1: The path to check
|
|
|
|
|
|
# Helper function which possibly converts a path using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
# $1: The path to check
|
|
|
|
|
|
# FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
|
|
# and could probably be heavily simplified. However, all changes in this
|
|
# area tend to need lot of testing in different scenarios, and in lack of
|
|
# proper unit testing, cleaning this up has not been deemed worth the effort
|
|
# at the moment.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Setup basic configuration paths, and platform-specific stuff related to PATHs.
|
|
|
|
|
|
|
|
|
|
# ... then the rest
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
########################################################################
|
|
# This file handles detection of the Boot JDK. The Boot JDK detection
|
|
# process has been developed as a response to solve a complex real-world
|
|
# problem. Initially, it was simple, but it has grown as platform after
|
|
# platform, idiosyncracy after idiosyncracy has been supported.
|
|
#
|
|
# The basic idea is this:
|
|
# 1) You need an acceptable *) JDK to use as a Boot JDK
|
|
# 2) There are several ways to locate a JDK, that are mostly platform
|
|
# dependent **)
|
|
# 3) You can have multiple JDKs installed
|
|
# 4) If possible, configure should try to dig out an acceptable JDK
|
|
# automatically, without having to resort to command-line options
|
|
#
|
|
# *) acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
|
|
# javac) and not a JRE, etc.
|
|
#
|
|
# **) On Windows we typically use a well-known path.
|
|
# On MacOSX we typically use the tool java_home.
|
|
# On Linux we typically find javac in the $PATH, and then follow a
|
|
# chain of symlinks that often ends up in a real JDK.
|
|
#
|
|
# This leads to the code where we check in different ways to locate a
|
|
# JDK, and if one is found, check if it is acceptable. If not, we print
|
|
# our reasons for rejecting it (useful when debugging non-working
|
|
# configure situations) and continue checking the next one.
|
|
########################################################################
|
|
|
|
# Execute the check given as argument, and verify the result
|
|
# If the Boot JDK was previously found, do nothing
|
|
# $1 A command line (typically autoconf macro) to execute
|
|
|
|
|
|
# Test: Is bootjdk explicitly set by command line arguments?
|
|
|
|
|
|
# Test: Is $JAVA_HOME set?
|
|
|
|
|
|
# Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
|
|
|
|
|
|
# Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
|
|
# $1: Argument to the java_home binary (optional)
|
|
|
|
|
|
# Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
|
|
|
|
|
|
# Look for a jdk in the given path. If there are multiple, try to select the newest.
|
|
# If found, set BOOT_JDK and BOOT_JDK_FOUND.
|
|
# $1 = Path to directory containing jdk installations.
|
|
# $2 = String to append to the found JDK directory to get the proper JDK home
|
|
|
|
|
|
# Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
|
|
# environmental variable as base for where to look.
|
|
# $1 Name of an environmal variable, assumed to point to the Program Files directory.
|
|
|
|
|
|
# Test: Is there a JDK installed in default, well-known locations?
|
|
|
|
|
|
# Check that a command-line tool in the Boot JDK is correct
|
|
# $1 = name of variable to assign
|
|
# $2 = name of binary
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# We need a Boot JDK to bootstrap the build.
|
|
#
|
|
|
|
|
|
|
|
|
|
|
|
# BUILD_JDK: the location of the latest JDK that can run
|
|
# on the host system and supports the target class file version
|
|
# generated in this JDK build. This variable should only be
|
|
# used after the launchers are built.
|
|
#
|
|
|
|
# Execute the check given as argument, and verify the result.
|
|
# If the JDK was previously found, do nothing.
|
|
# $1 A command line (typically autoconf macro) to execute
|
|
|
|
|
|
# By default the BUILD_JDK is the JDK_OUTPUTDIR. If the target architecture
|
|
# is different than the host system doing the build (e.g. cross-compilation),
|
|
# a special BUILD_JDK is built as part of the build process. An external
|
|
# prebuilt BUILD_JDK can also be supplied.
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Runs icecc-create-env once and prints the error if it fails
|
|
#
|
|
# $1: arguments to icecc-create-env
|
|
# $2: log file
|
|
#
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Optionally enable distributed compilation of native code using icecc/icecream
|
|
#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
#
|
|
# Setup ABI profile (for arm)
|
|
#
|
|
|
|
|
|
# Reset the global CFLAGS/LDFLAGS variables and initialize them with the
|
|
# corresponding configure arguments instead
|
|
|
|
|
|
# Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so
|
|
# that configure can use them while detecting compilers.
|
|
# TOOLCHAIN_TYPE is available here.
|
|
# Param 1 - Optional prefix to all variables. (e.g BUILD_)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Documentation on common flags used for solstudio in HIGHEST.
|
|
#
|
|
# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
|
|
# done with care, there are some assumptions below that need to
|
|
# be understood about the use of pointers, and IEEE behavior.
|
|
#
|
|
# -fns: Use non-standard floating point mode (not IEEE 754)
|
|
# -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
|
|
# -fsingle: Use single precision floating point with 'float'
|
|
# -xalias_level=basic: Assume memory references via basic pointer types do not alias
|
|
# (Source with excessing pointer casting and data access with mixed
|
|
# pointer types are not recommended)
|
|
# -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
|
|
# (If you expect perfect errno behavior, do not use this)
|
|
# -xdepend: Loop data dependency optimizations (need -xO3 or higher)
|
|
# -xrestrict: Pointer parameters to functions do not overlap
|
|
# (Similar to -xalias_level=basic usage, but less obvious sometimes.
|
|
# If you pass in multiple pointers to the same data, do not use this)
|
|
# -xlibmil: Inline some library routines
|
|
# (If you expect perfect errno behavior, do not use this)
|
|
# -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
|
|
# (If you expect perfect errno behavior, do not use this)
|
|
# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
|
|
|
|
# FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
|
|
# Bug?
|
|
#if test "x$OPENJDK_TARGET_CPU" = xsparc; then
|
|
# CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
|
|
# CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
|
|
#fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
################################################################################
|
|
# $1 - Either BUILD or TARGET to pick the correct OS/CPU variables to check
|
|
# conditionals against.
|
|
# $2 - Optional prefix for each variable defined.
|
|
|
|
|
|
# FLAGS_C_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
|
|
# IF_FALSE: [RUN-IF-FALSE])
|
|
# ------------------------------------------------------------
|
|
# Check that the C compiler supports an argument
|
|
|
|
|
|
|
|
|
|
# FLAGS_CXX_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
|
|
# IF_FALSE: [RUN-IF-FALSE])
|
|
# ------------------------------------------------------------
|
|
# Check that the C++ compiler supports an argument
|
|
|
|
|
|
|
|
|
|
# FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
|
|
# IF_FALSE: [RUN-IF-FALSE])
|
|
# ------------------------------------------------------------
|
|
# Check that the C and C++ compilers support an argument
|
|
|
|
|
|
|
|
|
|
# FLAGS_LINKER_CHECK_ARGUMENTS(ARGUMENT: [ARGUMENT], IF_TRUE: [RUN-IF-TRUE],
|
|
# IF_FALSE: [RUN-IF-FALSE])
|
|
# ------------------------------------------------------------
|
|
# Check that the linker support an argument
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# FLAGS_SETUP_GCC6_COMPILER_FLAGS([PREFIX])
|
|
# Arguments:
|
|
# $1 - Optional prefix for each variable defined.
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
|
|
|
|
|
|
|
|
cygwin_help() {
|
|
case $1 in
|
|
unzip)
|
|
PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
;;
|
|
zip)
|
|
PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
;;
|
|
make)
|
|
PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
;;
|
|
freetype)
|
|
HELP_MSG="
|
|
The freetype library can now be build during the configure process.
|
|
Download the freetype sources and unpack them into an arbitrary directory:
|
|
|
|
wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
|
|
tar -xzf freetype-2.5.3.tar.gz
|
|
|
|
Then run configure with '--with-freetype-src=<freetype_src>'. This will
|
|
automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
|
|
builds or into '<freetype_src>/lib32' for 32-bit builds.
|
|
Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
|
|
and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds.
|
|
|
|
Alternatively you can unpack the sources like this to use the default directory:
|
|
|
|
tar --one-top-level=$HOME/freetype --strip-components=1 -xzf freetype-2.5.3.tar.gz"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
msys_help() {
|
|
PKGHANDLER_COMMAND=""
|
|
}
|
|
|
|
apt_help() {
|
|
case $1 in
|
|
reduced)
|
|
PKGHANDLER_COMMAND="sudo apt-get install gcc-multilib g++-multilib" ;;
|
|
devkit)
|
|
PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
|
|
openjdk)
|
|
PKGHANDLER_COMMAND="sudo apt-get install openjdk-8-jdk" ;;
|
|
alsa)
|
|
PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
|
|
cups)
|
|
PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
|
|
freetype)
|
|
PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
|
|
ffi)
|
|
PKGHANDLER_COMMAND="sudo apt-get install libffi-dev" ;;
|
|
x11)
|
|
PKGHANDLER_COMMAND="sudo apt-get install libx11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
|
|
ccache)
|
|
PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
|
|
dtrace)
|
|
PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
|
|
esac
|
|
}
|
|
|
|
yum_help() {
|
|
case $1 in
|
|
devkit)
|
|
PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
|
|
openjdk)
|
|
PKGHANDLER_COMMAND="sudo yum install java-1.8.0-openjdk-devel" ;;
|
|
alsa)
|
|
PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
|
|
cups)
|
|
PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
|
|
freetype)
|
|
PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
|
|
x11)
|
|
PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
|
|
ccache)
|
|
PKGHANDLER_COMMAND="sudo yum install ccache" ;;
|
|
esac
|
|
}
|
|
|
|
brew_help() {
|
|
case $1 in
|
|
openjdk)
|
|
PKGHANDLER_COMMAND="brew cask install java" ;;
|
|
freetype)
|
|
PKGHANDLER_COMMAND="brew install freetype" ;;
|
|
ccache)
|
|
PKGHANDLER_COMMAND="brew install ccache" ;;
|
|
esac
|
|
}
|
|
|
|
port_help() {
|
|
PKGHANDLER_COMMAND=""
|
|
}
|
|
|
|
pkgutil_help() {
|
|
PKGHANDLER_COMMAND=""
|
|
}
|
|
|
|
pkgadd_help() {
|
|
PKGHANDLER_COMMAND=""
|
|
}
|
|
|
|
# This function will check if we're called from the "configure" wrapper while
|
|
# printing --help. If so, we will print out additional information that can
|
|
# only be extracted within the autoconf script, and then exit. This must be
|
|
# called at the very beginning in configure.ac.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
# All valid JVM features, regardless of platform
|
|
VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
|
|
graal vm-structs jni-check services management all-gcs nmt cds \
|
|
static-build link-time-opt aot"
|
|
|
|
# All valid JVM variants
|
|
VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
|
|
|
|
###############################################################################
|
|
# Check if the specified JVM variant should be built. To be used in shell if
|
|
# constructs, like this:
|
|
# if HOTSPOT_CHECK_JVM_VARIANT(server); then
|
|
#
|
|
# Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
|
|
|
|
# Definition kept in one line to allow inlining in if statements.
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
|
|
|
|
###############################################################################
|
|
# Check if the specified JVM features are explicitly enabled. To be used in
|
|
# shell if constructs, like this:
|
|
# if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
|
|
#
|
|
# Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
|
|
|
|
# Definition kept in one line to allow inlining in if statements.
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
|
|
|
|
###############################################################################
|
|
# Check which variants of the JVM that we want to build. Available variants are:
|
|
# server: normal interpreter, and a tiered C1/C2 compiler
|
|
# client: normal interpreter, and C1 (no C2 compiler)
|
|
# minimal: reduced form of client with optional features stripped out
|
|
# core: normal interpreter only, no compiler
|
|
# zero: C++ based interpreter only, no compiler
|
|
# zeroshark: C++ based interpreter, and a llvm-based compiler
|
|
# custom: baseline JVM with no default features
|
|
#
|
|
|
|
|
|
###############################################################################
|
|
# Check if dtrace should be enabled and has all prerequisites present.
|
|
#
|
|
|
|
|
|
################################################################################
|
|
# Check if AOT should be enabled
|
|
#
|
|
|
|
|
|
################################################################################
|
|
# Allow to disable CDS
|
|
#
|
|
|
|
|
|
###############################################################################
|
|
# Set up all JVM features for each JVM variant.
|
|
#
|
|
|
|
|
|
###############################################################################
|
|
# Validate JVM features once all setup is complete, including custom setup.
|
|
#
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Specify which sources will be used to build the 64-bit ARM port
|
|
#
|
|
# --with-cpu-port=arm64 will use hotspot/src/cpu/arm
|
|
# --with-cpu-port=aarch64 will use hotspot/src/cpu/aarch64
|
|
#
|
|
|
|
|
|
|
|
################################################################################
|
|
# Check if gtest should be built
|
|
#
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
###############################################################################
|
|
# Check which variant of the JDK that we want to build.
|
|
# Currently we have:
|
|
# normal: standard edition
|
|
# but the custom make system may add other variants
|
|
#
|
|
# Effectively the JDK variant gives a name to a specific set of
|
|
# modules to compile into the JDK.
|
|
|
|
|
|
###############################################################################
|
|
# Set the debug level
|
|
# release: no debug information, all optimizations, no asserts.
|
|
# optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
|
|
# fastdebug: debug information (-g), all optimizations, all asserts
|
|
# slowdebug: debug information (-g), no optimizations, all asserts
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Should we build only OpenJDK even if closed sources are present?
|
|
#
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Enable or disable the elliptic curve crypto implementation
|
|
#
|
|
|
|
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Gcov coverage data for hotspot
|
|
#
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Static build support. When enabled will generate static
|
|
# libraries instead of shared libraries for all JDK libs.
|
|
#
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# jlink options.
|
|
# We always keep packaged modules in JDK image.
|
|
#
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Check if building of the jtreg failure handler should be enabled.
|
|
#
|
|
|
|
|
|
################################################################################
|
|
#
|
|
# Enable or disable generation of the classlist at build time
|
|
#
|
|
|
|
|
|
#
|
|
# Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
###############################################################################
|
|
#
|
|
# Setup version numbers
|
|
#
|
|
|
|
# Verify that a given string represents a valid version number, and assign it
|
|
# to a variable.
|
|
|
|
# Argument 1: the variable to assign to
|
|
# Argument 2: the value given by the user
|
|
|
|
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
# Major library component reside in separate files.
|
|
#
|
|
# Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Setup alsa (Advanced Linux Sound Architecture)
|
|
################################################################################
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Setup bundled libraries.
|
|
#
|
|
# For libjpeg, giflib, libpng, lcms2 and zlib, the source is present in the
|
|
# OpenJDK repository. Default is to use these libraries as bundled, but they
|
|
# might be replaced by en external version by the user.
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup libjpeg
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup giflib
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup libpng
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup zlib
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup lcms (Little CMS)
|
|
################################################################################
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Setup cups (Common Unix Printing System)
|
|
################################################################################
|
|
|
|
|
|
#
|
|
# Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Setup libffi (Foreign Function Interface)
|
|
################################################################################
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Build the freetype lib from source
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Check if a potential freeype library match is correct and usable
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup freetype (The FreeType2 font rendering library)
|
|
################################################################################
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Setup the standard C/C++ runtime libraries.
|
|
#
|
|
# Most importantly, determine if stdc++ should be linked statically or
|
|
# dynamically.
|
|
################################################################################
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# Setup X11 Windows system
|
|
################################################################################
|
|
|
|
|
|
|
|
################################################################################
|
|
# Determine which libraries are needed for this configuration
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Parse library options, and setup needed libraries
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup llvm (Low-Level VM)
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# Setup various libraries, typically small system libraries
|
|
################################################################################
|
|
|
|
|
|
################################################################################
|
|
# libstlport.so.1 is needed for running gtest on Solaris. Find it to
|
|
# redistribute it in the test image.
|
|
################################################################################
|
|
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
|
|
# Converts autoconf style CPU name to OpenJDK style, into
|
|
# VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
|
|
|
|
|
|
# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
|
|
# Converts autoconf style OS name to OpenJDK style, into
|
|
# VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
|
|
|
|
|
|
# Expects $host_os $host_cpu $build_os and $build_cpu
|
|
# and $with_target_bits to have been setup!
|
|
#
|
|
# Translate the standard triplet(quadruplet) definition
|
|
# of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
|
|
# OPENJDK_BUILD_OS, etc.
|
|
|
|
|
|
# Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
|
|
# accordingly. Must be done after setting up build and target system, but before
|
|
# doing anything else with these values.
|
|
|
|
|
|
# Setup the legacy variables, for controlling the old makefiles.
|
|
#
|
|
|
|
|
|
# $1 - Either TARGET or BUILD to setup the variables for.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#%%% Build and target systems %%%
|
|
|
|
|
|
|
|
|
|
# Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
|
|
# Add -mX to various FLAGS variables.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
################################################################################
|
|
# Define a mechanism for importing extra prebuilt modules
|
|
#
|
|
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
########################################################################
|
|
# This file is responsible for detecting, verifying and setting up the
|
|
# toolchain, i.e. the compiler, linker and related utilities. It will setup
|
|
# proper paths to the binaries, but it will not setup any flags.
|
|
#
|
|
# The binaries used is determined by the toolchain type, which is the family of
|
|
# compilers and related tools that are used.
|
|
########################################################################
|
|
|
|
|
|
# All valid toolchains, regardless of platform (used by help.m4)
|
|
VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
|
|
|
|
# These toolchains are valid on different platforms
|
|
VALID_TOOLCHAINS_linux="gcc clang"
|
|
VALID_TOOLCHAINS_solaris="solstudio"
|
|
VALID_TOOLCHAINS_macosx="gcc clang"
|
|
VALID_TOOLCHAINS_aix="xlc"
|
|
VALID_TOOLCHAINS_windows="microsoft"
|
|
|
|
# Toolchain descriptions
|
|
TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
|
|
TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
|
|
TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
|
|
TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
|
|
TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
|
|
|
|
# Minimum supported versions, empty means unspecified
|
|
TOOLCHAIN_MINIMUM_VERSION_clang="3.2"
|
|
TOOLCHAIN_MINIMUM_VERSION_gcc="4.7"
|
|
TOOLCHAIN_MINIMUM_VERSION_microsoft="16.00.30319.01" # VS2010
|
|
TOOLCHAIN_MINIMUM_VERSION_solstudio="5.13"
|
|
TOOLCHAIN_MINIMUM_VERSION_xlc=""
|
|
|
|
# Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
|
|
# Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
|
|
# $1 - optional variable prefix for compiler and version variables (BUILD_)
|
|
# $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
|
|
|
|
|
|
# Check if the configured compiler (C and C++) is of a specific version or
|
|
# newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
|
|
#
|
|
# Arguments:
|
|
# VERSION: The version string to check against the found version
|
|
# IF_AT_LEAST: block to run if the compiler is at least this version (>=)
|
|
# IF_OLDER_THAN: block to run if the compiler is older than this version (<)
|
|
# PREFIX: Optional variable prefix for compiler to compare version for (OPENJDK_BUILD_)
|
|
|
|
|
|
|
|
|
|
# Setup a number of variables describing how native output files are
|
|
# named on this platform/toolchain.
|
|
|
|
|
|
# Determine which toolchain type to use, and make sure it is valid for this
|
|
# platform. Setup various information about the selected toolchain.
|
|
|
|
|
|
# Before we start detecting the toolchain executables, we might need some
|
|
# special setup, e.g. additional paths etc.
|
|
|
|
|
|
# Restore path, etc
|
|
|
|
|
|
# Check if a compiler is of the toolchain type we expect, and save the version
|
|
# information from it. If the compiler does not match the expected type,
|
|
# this function will abort using AC_MSG_ERROR. If it matches, the version will
|
|
# be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
|
|
# the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
|
|
#
|
|
# $1 = compiler to test (CC or CXX)
|
|
# $2 = human readable name of compiler (C or C++)
|
|
|
|
|
|
# Try to locate the given C or C++ compiler in the path, or otherwise.
|
|
#
|
|
# $1 = compiler to test (CC or CXX)
|
|
# $2 = human readable name of compiler (C or C++)
|
|
# $3 = compiler name to search for
|
|
|
|
|
|
# Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
|
|
# preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
|
|
# archiver (AR). Verify that the compilers are correct according to the
|
|
# toolchain type.
|
|
|
|
|
|
# Setup additional tools that is considered a part of the toolchain, but not the
|
|
# core part. Many of these are highly platform-specific and do not exist,
|
|
# and/or are not needed on all platforms.
|
|
|
|
|
|
# Setup the build tools (i.e, the compiler and linker used to build programs
|
|
# that should be run on the build platform, not the target platform, as a build
|
|
# helper). Since the non-cross-compile case uses the normal, target compilers
|
|
# for this, we can only do this after these have been setup.
|
|
|
|
|
|
# Do some additional checks on the detected tools.
|
|
|
|
|
|
# Setup the JTReg Regression Test Harness.
|
|
|
|
|
|
# Setup the JIB dependency resolver
|
|
|
|
|
|
#
|
|
# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# This code is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License version 2 only, as
|
|
# published by the Free Software Foundation. Oracle designates this
|
|
# particular file as subject to the "Classpath" exception as provided
|
|
# by Oracle in the LICENSE file that accompanied this code.
|
|
#
|
|
# This code is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# version 2 for more details (a copy is included in the LICENSE file that
|
|
# accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU General Public License version
|
|
# 2 along with this work; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
# or visit www.oracle.com if you need additional information or have any
|
|
# questions.
|
|
#
|
|
|
|
################################################################################
|
|
# The order of these defines the priority by which we try to find them.
|
|
VALID_VS_VERSIONS="2013 2012 2010"
|
|
|
|
VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
|
|
VS_VERSION_INTERNAL_2010=100
|
|
VS_MSVCR_2010=msvcr100.dll
|
|
# We don't use msvcp on Visual Studio 2010
|
|
#VS_MSVCP_2010=msvcp100.dll
|
|
VS_ENVVAR_2010="VS100COMNTOOLS"
|
|
VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
|
|
VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
|
|
VS_VS_PLATFORM_NAME_2010="v100"
|
|
VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
|
|
|
|
VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
|
|
VS_VERSION_INTERNAL_2012=110
|
|
VS_MSVCR_2012=msvcr110.dll
|
|
VS_MSVCP_2012=msvcp110.dll
|
|
VS_ENVVAR_2012="VS110COMNTOOLS"
|
|
VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
|
|
VS_SDK_INSTALLDIR_2012=
|
|
VS_VS_PLATFORM_NAME_2012="v110"
|
|
VS_SDK_PLATFORM_NAME_2012=
|
|
|
|
VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
|
|
VS_VERSION_INTERNAL_2013=120
|
|
VS_MSVCR_2013=msvcr120.dll
|
|
VS_MSVCP_2013=msvcp120.dll
|
|
VS_ENVVAR_2013="VS120COMNTOOLS"
|
|
VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
|
|
VS_SDK_INSTALLDIR_2013=
|
|
VS_VS_PLATFORM_NAME_2013="v120"
|
|
VS_SDK_PLATFORM_NAME_2013=
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
################################################################################
|
|
# Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
|
|
# build environment and assigns it to VS_ENV_CMD
|
|
|
|
|
|
################################################################################
|
|
|
|
|
|
|
|
################################################################################
|
|
# Check if the VS env variables were setup prior to running configure.
|
|
# If not, then find vcvarsall.bat and run it automatically, and integrate
|
|
# the set env variables into the spec file.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# This line needs to be here, verbatim, after all includes and the dummy hook
|
|
# definitions. It is replaced with custom functionality when building
|
|
# custom sources.
|
|
#CUSTOM_AUTOCONF_INCLUDE
|
|
|
|
# Do not change or remove the following line, it is needed for consistency checks:
|
|
DATE_WHEN_GENERATED=1504441177
|
|
|
|
###############################################################################
|
|
#
|
|
# Initialization / Boot-strapping
|
|
#
|
|
# The bootstrapping process needs to solve the "chicken or the egg" problem,
|
|
# thus it jumps back and forth, each time gaining something needed later on.
|
|
#
|
|
###############################################################################
|
|
|
|
# If we are requested to print additional help, do that and then exit.
|
|
# This must be the very first call.
|
|
|
|
if test "x$CONFIGURE_PRINT_ADDITIONAL_HELP" != x; then
|
|
|
|
# Print available toolchains
|
|
$PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
|
|
$PRINTF "Which are valid to use depends on the build platform.\n"
|
|
for toolchain in $VALID_TOOLCHAINS_all; do
|
|
# Use indirect variable referencing
|
|
toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
|
|
TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
|
|
$PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
|
|
done
|
|
$PRINTF "\n"
|
|
|
|
# Print available jvm features
|
|
$PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
|
|
$PRINTF "Which are valid to use depends on the target platform.\n "
|
|
$PRINTF "%s " $VALID_JVM_FEATURES
|
|
$PRINTF "\n"
|
|
|
|
# And now exit directly
|
|
exit 0
|
|
fi
|
|
|
|
|
|
# Basic initialization that must happen first of all in the normal process.
|
|
|
|
# Save the original command line. This is passed to us by the wrapper configure script.
|
|
|
|
# Save the path variable before it gets changed
|
|
ORIGINAL_PATH="$PATH"
|
|
|
|
DATE_WHEN_CONFIGURED=`LANG=C date`
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
|
|
$as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
|
|
$as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
|
|
|
|
|
|
# Start with tools that do not need have cross compilation support
|
|
# and can be expected to be found in the default PATH. These tools are
|
|
# used by configure.
|
|
|
|
# First are all the simple required tools.
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BASENAME+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in basename
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BASENAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BASENAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BASENAME=$ac_cv_path_BASENAME
|
|
if test -n "$BASENAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
|
|
$as_echo "$BASENAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BASENAME" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BASENAME! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBASENAME" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in basename
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BASENAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BASENAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BASENAME=$ac_cv_path_BASENAME
|
|
if test -n "$BASENAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
|
|
$as_echo "$BASENAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BASENAME" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BASENAME" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASENAME= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BASENAME= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
|
|
$as_echo_n "checking for BASENAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BASENAME"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BASENAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BASENAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BASENAME=$ac_cv_path_BASENAME
|
|
if test -n "$BASENAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
|
|
$as_echo "$BASENAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BASENAME" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
|
|
$as_echo_n "checking for BASENAME... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$BASENAME" = x; then
|
|
as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BASH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in bash
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BASH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BASH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BASH=$ac_cv_path_BASH
|
|
if test -n "$BASH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
|
|
$as_echo "$BASH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BASH" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BASH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBASH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in bash
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BASH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BASH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BASH=$ac_cv_path_BASH
|
|
if test -n "$BASH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
|
|
$as_echo "$BASH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BASH" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BASH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BASH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BASH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
|
|
$as_echo_n "checking for BASH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BASH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BASH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BASH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BASH=$ac_cv_path_BASH
|
|
if test -n "$BASH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
|
|
$as_echo "$BASH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BASH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
|
|
$as_echo_n "checking for BASH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$BASH" = x; then
|
|
as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CAT+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cat
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CAT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CAT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CAT=$ac_cv_path_CAT
|
|
if test -n "$CAT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
|
|
$as_echo "$CAT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CAT" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CAT! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCAT" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cat
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CAT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CAT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CAT=$ac_cv_path_CAT
|
|
if test -n "$CAT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
|
|
$as_echo "$CAT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CAT" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CAT" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CAT= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CAT= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
|
|
$as_echo_n "checking for CAT... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CAT"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CAT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CAT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CAT=$ac_cv_path_CAT
|
|
if test -n "$CAT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
|
|
$as_echo "$CAT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CAT" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
|
|
$as_echo_n "checking for CAT... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$CAT" = x; then
|
|
as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CHMOD+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in chmod
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHMOD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHMOD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHMOD=$ac_cv_path_CHMOD
|
|
if test -n "$CHMOD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
|
|
$as_echo "$CHMOD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHMOD" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CHMOD! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCHMOD" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in chmod
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHMOD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHMOD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHMOD=$ac_cv_path_CHMOD
|
|
if test -n "$CHMOD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
|
|
$as_echo "$CHMOD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHMOD" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CHMOD" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CHMOD= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CHMOD= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
|
|
$as_echo_n "checking for CHMOD... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CHMOD"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHMOD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHMOD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHMOD=$ac_cv_path_CHMOD
|
|
if test -n "$CHMOD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
|
|
$as_echo "$CHMOD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CHMOD" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
|
|
$as_echo_n "checking for CHMOD... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$CHMOD" = x; then
|
|
as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CMP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cmp
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CMP=$ac_cv_path_CMP
|
|
if test -n "$CMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
|
|
$as_echo "$CMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CMP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CMP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCMP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cmp
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CMP=$ac_cv_path_CMP
|
|
if test -n "$CMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
|
|
$as_echo "$CMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CMP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CMP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CMP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CMP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
|
|
$as_echo_n "checking for CMP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CMP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CMP=$ac_cv_path_CMP
|
|
if test -n "$CMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
|
|
$as_echo "$CMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CMP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
|
|
$as_echo_n "checking for CMP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$CMP" = x; then
|
|
as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${COMM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in comm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_COMM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $COMM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
COMM=$ac_cv_path_COMM
|
|
if test -n "$COMM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
|
|
$as_echo "$COMM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$COMM" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !COMM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCOMM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in comm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_COMM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $COMM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
COMM=$ac_cv_path_COMM
|
|
if test -n "$COMM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
|
|
$as_echo "$COMM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$COMM" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$COMM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool COMM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool COMM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
|
|
$as_echo_n "checking for COMM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$COMM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_COMM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $COMM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
COMM=$ac_cv_path_COMM
|
|
if test -n "$COMM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
|
|
$as_echo "$COMM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$COMM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
|
|
$as_echo_n "checking for COMM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$COMM" = x; then
|
|
as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cp
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CP="$CP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CP=$ac_cv_path_CP
|
|
if test -n "$CP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
|
|
$as_echo "$CP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cp
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CP="$CP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CP=$ac_cv_path_CP
|
|
if test -n "$CP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
|
|
$as_echo "$CP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
|
|
$as_echo_n "checking for CP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CP="$CP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CP=$ac_cv_path_CP
|
|
if test -n "$CP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
|
|
$as_echo "$CP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
|
|
$as_echo_n "checking for CP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$CP" = x; then
|
|
as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CUT+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cut
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CUT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CUT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CUT=$ac_cv_path_CUT
|
|
if test -n "$CUT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
|
|
$as_echo "$CUT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CUT" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CUT! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCUT" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cut
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CUT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CUT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CUT=$ac_cv_path_CUT
|
|
if test -n "$CUT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
|
|
$as_echo "$CUT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CUT" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CUT" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CUT= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CUT= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
|
|
$as_echo_n "checking for CUT... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CUT"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CUT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CUT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CUT=$ac_cv_path_CUT
|
|
if test -n "$CUT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
|
|
$as_echo "$CUT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CUT" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
|
|
$as_echo_n "checking for CUT... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$CUT" = x; then
|
|
as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DATE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in date
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DATE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DATE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DATE=$ac_cv_path_DATE
|
|
if test -n "$DATE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
|
|
$as_echo "$DATE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DATE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DATE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDATE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in date
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DATE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DATE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DATE=$ac_cv_path_DATE
|
|
if test -n "$DATE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
|
|
$as_echo "$DATE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DATE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DATE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DATE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DATE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
|
|
$as_echo_n "checking for DATE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DATE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DATE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DATE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DATE=$ac_cv_path_DATE
|
|
if test -n "$DATE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
|
|
$as_echo "$DATE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DATE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
|
|
$as_echo_n "checking for DATE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$DATE" = x; then
|
|
as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DIFF+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in gdiff diff
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DIFF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DIFF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DIFF=$ac_cv_path_DIFF
|
|
if test -n "$DIFF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
|
|
$as_echo "$DIFF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DIFF" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DIFF! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDIFF" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in gdiff diff
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DIFF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DIFF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DIFF=$ac_cv_path_DIFF
|
|
if test -n "$DIFF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
|
|
$as_echo "$DIFF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DIFF" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DIFF" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIFF= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DIFF= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
|
|
$as_echo_n "checking for DIFF... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DIFF"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DIFF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DIFF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DIFF=$ac_cv_path_DIFF
|
|
if test -n "$DIFF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
|
|
$as_echo "$DIFF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DIFF" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
|
|
$as_echo_n "checking for DIFF... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$DIFF" = x; then
|
|
as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DIRNAME+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in dirname
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DIRNAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DIRNAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DIRNAME=$ac_cv_path_DIRNAME
|
|
if test -n "$DIRNAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
|
|
$as_echo "$DIRNAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DIRNAME" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DIRNAME! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDIRNAME" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in dirname
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DIRNAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DIRNAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DIRNAME=$ac_cv_path_DIRNAME
|
|
if test -n "$DIRNAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
|
|
$as_echo "$DIRNAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DIRNAME" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DIRNAME" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DIRNAME= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DIRNAME= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
|
|
$as_echo_n "checking for DIRNAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DIRNAME"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DIRNAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DIRNAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DIRNAME=$ac_cv_path_DIRNAME
|
|
if test -n "$DIRNAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
|
|
$as_echo "$DIRNAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DIRNAME" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
|
|
$as_echo_n "checking for DIRNAME... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$DIRNAME" = x; then
|
|
as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${ECHO+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in echo
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ECHO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ECHO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ECHO=$ac_cv_path_ECHO
|
|
if test -n "$ECHO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
|
|
$as_echo "$ECHO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ECHO" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !ECHO! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xECHO" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in echo
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ECHO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ECHO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ECHO=$ac_cv_path_ECHO
|
|
if test -n "$ECHO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
|
|
$as_echo "$ECHO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ECHO" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$ECHO" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ECHO= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool ECHO= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
|
|
$as_echo_n "checking for ECHO... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$ECHO"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ECHO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ECHO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ECHO=$ac_cv_path_ECHO
|
|
if test -n "$ECHO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
|
|
$as_echo "$ECHO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$ECHO" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
|
|
$as_echo_n "checking for ECHO... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$ECHO" = x; then
|
|
as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${EXPR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in expr
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_EXPR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $EXPR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
EXPR=$ac_cv_path_EXPR
|
|
if test -n "$EXPR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
|
|
$as_echo "$EXPR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$EXPR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !EXPR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xEXPR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in expr
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_EXPR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $EXPR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
EXPR=$ac_cv_path_EXPR
|
|
if test -n "$EXPR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
|
|
$as_echo "$EXPR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$EXPR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$EXPR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EXPR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool EXPR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
|
|
$as_echo_n "checking for EXPR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$EXPR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_EXPR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $EXPR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
EXPR=$ac_cv_path_EXPR
|
|
if test -n "$EXPR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
|
|
$as_echo "$EXPR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$EXPR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
|
|
$as_echo_n "checking for EXPR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$EXPR" = x; then
|
|
as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${FILE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in file
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FILE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FILE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FILE=$ac_cv_path_FILE
|
|
if test -n "$FILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
|
|
$as_echo "$FILE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$FILE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !FILE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xFILE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in file
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FILE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FILE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FILE=$ac_cv_path_FILE
|
|
if test -n "$FILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
|
|
$as_echo "$FILE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$FILE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$FILE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FILE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool FILE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
|
|
$as_echo_n "checking for FILE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$FILE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FILE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FILE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FILE=$ac_cv_path_FILE
|
|
if test -n "$FILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
|
|
$as_echo "$FILE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$FILE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
|
|
$as_echo_n "checking for FILE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$FILE" = x; then
|
|
as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${FIND+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in find
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FIND+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FIND in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FIND=$ac_cv_path_FIND
|
|
if test -n "$FIND"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
|
|
$as_echo "$FIND" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$FIND" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !FIND! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xFIND" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in find
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FIND+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FIND in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FIND=$ac_cv_path_FIND
|
|
if test -n "$FIND"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
|
|
$as_echo "$FIND" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$FIND" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$FIND" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FIND= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool FIND= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
|
|
$as_echo_n "checking for FIND... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$FIND"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FIND+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FIND in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FIND=$ac_cv_path_FIND
|
|
if test -n "$FIND"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
|
|
$as_echo "$FIND" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$FIND" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
|
|
$as_echo_n "checking for FIND... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$FIND" = x; then
|
|
as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${HEAD+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in head
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_HEAD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $HEAD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
HEAD=$ac_cv_path_HEAD
|
|
if test -n "$HEAD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
|
|
$as_echo "$HEAD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$HEAD" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !HEAD! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xHEAD" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in head
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_HEAD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $HEAD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
HEAD=$ac_cv_path_HEAD
|
|
if test -n "$HEAD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
|
|
$as_echo "$HEAD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$HEAD" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$HEAD" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HEAD= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool HEAD= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
|
|
$as_echo_n "checking for HEAD... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$HEAD"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_HEAD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $HEAD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
HEAD=$ac_cv_path_HEAD
|
|
if test -n "$HEAD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
|
|
$as_echo "$HEAD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$HEAD" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
|
|
$as_echo_n "checking for HEAD... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$HEAD" = x; then
|
|
as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${GUNZIP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in gunzip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GUNZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GUNZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GUNZIP=$ac_cv_path_GUNZIP
|
|
if test -n "$GUNZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
|
|
$as_echo "$GUNZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$GUNZIP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !GUNZIP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GUNZIP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xGUNZIP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of GUNZIP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in gunzip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GUNZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GUNZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GUNZIP=$ac_cv_path_GUNZIP
|
|
if test -n "$GUNZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
|
|
$as_echo "$GUNZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$GUNZIP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$GUNZIP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GUNZIP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool GUNZIP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
|
|
$as_echo_n "checking for GUNZIP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$GUNZIP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GUNZIP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool GUNZIP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GUNZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GUNZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GUNZIP="$GUNZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GUNZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GUNZIP=$ac_cv_path_GUNZIP
|
|
if test -n "$GUNZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GUNZIP" >&5
|
|
$as_echo "$GUNZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$GUNZIP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GUNZIP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool GUNZIP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GUNZIP" >&5
|
|
$as_echo_n "checking for GUNZIP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool GUNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$GUNZIP" = x; then
|
|
as_fn_error $? "Could not find required tool for GUNZIP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${GZIP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in pigz gzip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GZIP=$ac_cv_path_GZIP
|
|
if test -n "$GZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
|
|
$as_echo "$GZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$GZIP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !GZIP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GZIP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xGZIP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of GZIP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in pigz gzip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GZIP=$ac_cv_path_GZIP
|
|
if test -n "$GZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
|
|
$as_echo "$GZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$GZIP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$GZIP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GZIP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool GZIP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
|
|
$as_echo_n "checking for GZIP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$GZIP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GZIP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool GZIP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GZIP="$GZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GZIP=$ac_cv_path_GZIP
|
|
if test -n "$GZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GZIP" >&5
|
|
$as_echo "$GZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$GZIP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GZIP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool GZIP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GZIP" >&5
|
|
$as_echo_n "checking for GZIP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool GZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$GZIP" = x; then
|
|
as_fn_error $? "Could not find required tool for GZIP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${LN+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in ln
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LN in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LN="$LN" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LN=$ac_cv_path_LN
|
|
if test -n "$LN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
|
|
$as_echo "$LN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LN" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !LN! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xLN" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in ln
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LN in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LN="$LN" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LN=$ac_cv_path_LN
|
|
if test -n "$LN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
|
|
$as_echo "$LN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LN" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$LN" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LN= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool LN= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
|
|
$as_echo_n "checking for LN... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$LN"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LN in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LN="$LN" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LN=$ac_cv_path_LN
|
|
if test -n "$LN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
|
|
$as_echo "$LN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$LN" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
|
|
$as_echo_n "checking for LN... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$LN" = x; then
|
|
as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${LS+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in ls
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LS="$LS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LS=$ac_cv_path_LS
|
|
if test -n "$LS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
|
|
$as_echo "$LS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LS" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !LS! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xLS" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in ls
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LS="$LS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LS=$ac_cv_path_LS
|
|
if test -n "$LS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
|
|
$as_echo "$LS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LS" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$LS" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LS= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool LS= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
|
|
$as_echo_n "checking for LS... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$LS"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LS="$LS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LS=$ac_cv_path_LS
|
|
if test -n "$LS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
|
|
$as_echo "$LS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$LS" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
|
|
$as_echo_n "checking for LS... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$LS" = x; then
|
|
as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${MKDIR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in mkdir
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MKDIR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MKDIR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MKDIR=$ac_cv_path_MKDIR
|
|
if test -n "$MKDIR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
|
|
$as_echo "$MKDIR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$MKDIR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !MKDIR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xMKDIR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in mkdir
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MKDIR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MKDIR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MKDIR=$ac_cv_path_MKDIR
|
|
if test -n "$MKDIR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
|
|
$as_echo "$MKDIR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$MKDIR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$MKDIR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKDIR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool MKDIR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
|
|
$as_echo_n "checking for MKDIR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$MKDIR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MKDIR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MKDIR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MKDIR=$ac_cv_path_MKDIR
|
|
if test -n "$MKDIR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
|
|
$as_echo "$MKDIR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$MKDIR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
|
|
$as_echo_n "checking for MKDIR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$MKDIR" = x; then
|
|
as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${MKTEMP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in mktemp
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MKTEMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MKTEMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MKTEMP=$ac_cv_path_MKTEMP
|
|
if test -n "$MKTEMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
|
|
$as_echo "$MKTEMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$MKTEMP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !MKTEMP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xMKTEMP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in mktemp
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MKTEMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MKTEMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MKTEMP=$ac_cv_path_MKTEMP
|
|
if test -n "$MKTEMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
|
|
$as_echo "$MKTEMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$MKTEMP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$MKTEMP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MKTEMP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool MKTEMP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
|
|
$as_echo_n "checking for MKTEMP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$MKTEMP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MKTEMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MKTEMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MKTEMP=$ac_cv_path_MKTEMP
|
|
if test -n "$MKTEMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
|
|
$as_echo "$MKTEMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$MKTEMP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
|
|
$as_echo_n "checking for MKTEMP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$MKTEMP" = x; then
|
|
as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${MV+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in mv
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MV+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MV in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MV="$MV" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MV=$ac_cv_path_MV
|
|
if test -n "$MV"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
|
|
$as_echo "$MV" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$MV" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !MV! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xMV" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in mv
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MV+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MV in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MV="$MV" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MV=$ac_cv_path_MV
|
|
if test -n "$MV"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
|
|
$as_echo "$MV" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$MV" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$MV" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MV= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool MV= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
|
|
$as_echo_n "checking for MV... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$MV"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MV+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MV in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MV="$MV" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MV=$ac_cv_path_MV
|
|
if test -n "$MV"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
|
|
$as_echo "$MV" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$MV" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
|
|
$as_echo_n "checking for MV... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$MV" = x; then
|
|
as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${NAWK+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in nawk gawk awk
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NAWK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NAWK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NAWK=$ac_cv_path_NAWK
|
|
if test -n "$NAWK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
|
|
$as_echo "$NAWK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NAWK" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !NAWK! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xNAWK" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in nawk gawk awk
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NAWK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NAWK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NAWK=$ac_cv_path_NAWK
|
|
if test -n "$NAWK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
|
|
$as_echo "$NAWK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NAWK" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$NAWK" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NAWK= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool NAWK= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
|
|
$as_echo_n "checking for NAWK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$NAWK"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NAWK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NAWK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NAWK=$ac_cv_path_NAWK
|
|
if test -n "$NAWK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
|
|
$as_echo "$NAWK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$NAWK" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
|
|
$as_echo_n "checking for NAWK... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$NAWK" = x; then
|
|
as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${PRINTF+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in printf
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PRINTF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PRINTF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PRINTF=$ac_cv_path_PRINTF
|
|
if test -n "$PRINTF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
|
|
$as_echo "$PRINTF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PRINTF" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !PRINTF! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xPRINTF" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in printf
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PRINTF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PRINTF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PRINTF=$ac_cv_path_PRINTF
|
|
if test -n "$PRINTF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
|
|
$as_echo "$PRINTF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PRINTF" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$PRINTF" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PRINTF= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool PRINTF= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
|
|
$as_echo_n "checking for PRINTF... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$PRINTF"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PRINTF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PRINTF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PRINTF=$ac_cv_path_PRINTF
|
|
if test -n "$PRINTF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
|
|
$as_echo "$PRINTF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$PRINTF" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
|
|
$as_echo_n "checking for PRINTF... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$PRINTF" = x; then
|
|
as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${RM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in rm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_RM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $RM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_RM="$RM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
RM=$ac_cv_path_RM
|
|
if test -n "$RM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
|
|
$as_echo "$RM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$RM" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !RM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xRM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in rm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_RM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $RM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_RM="$RM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
RM=$ac_cv_path_RM
|
|
if test -n "$RM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
|
|
$as_echo "$RM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$RM" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$RM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool RM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
|
|
$as_echo_n "checking for RM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$RM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_RM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $RM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_RM="$RM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
RM=$ac_cv_path_RM
|
|
if test -n "$RM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
|
|
$as_echo "$RM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$RM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
|
|
$as_echo_n "checking for RM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$RM" = x; then
|
|
as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${RMDIR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in rmdir
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_RMDIR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $RMDIR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
RMDIR=$ac_cv_path_RMDIR
|
|
if test -n "$RMDIR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
|
|
$as_echo "$RMDIR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$RMDIR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !RMDIR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RMDIR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xRMDIR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of RMDIR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in rmdir
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_RMDIR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $RMDIR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
RMDIR=$ac_cv_path_RMDIR
|
|
if test -n "$RMDIR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
|
|
$as_echo "$RMDIR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$RMDIR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$RMDIR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool RMDIR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool RMDIR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
|
|
$as_echo_n "checking for RMDIR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$RMDIR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RMDIR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool RMDIR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_RMDIR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $RMDIR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_RMDIR="$RMDIR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_RMDIR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
RMDIR=$ac_cv_path_RMDIR
|
|
if test -n "$RMDIR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RMDIR" >&5
|
|
$as_echo "$RMDIR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$RMDIR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RMDIR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool RMDIR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for RMDIR" >&5
|
|
$as_echo_n "checking for RMDIR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool RMDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$RMDIR" = x; then
|
|
as_fn_error $? "Could not find required tool for RMDIR" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${SH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in sh
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SH="$SH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SH=$ac_cv_path_SH
|
|
if test -n "$SH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
|
|
$as_echo "$SH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$SH" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !SH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in sh
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SH="$SH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SH=$ac_cv_path_SH
|
|
if test -n "$SH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
|
|
$as_echo "$SH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$SH" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$SH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool SH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
|
|
$as_echo_n "checking for SH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$SH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SH="$SH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SH=$ac_cv_path_SH
|
|
if test -n "$SH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
|
|
$as_echo "$SH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$SH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
|
|
$as_echo_n "checking for SH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$SH" = x; then
|
|
as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${SORT+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in sort
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SORT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SORT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SORT=$ac_cv_path_SORT
|
|
if test -n "$SORT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
|
|
$as_echo "$SORT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$SORT" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !SORT! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSORT" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in sort
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SORT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SORT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SORT=$ac_cv_path_SORT
|
|
if test -n "$SORT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
|
|
$as_echo "$SORT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$SORT" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$SORT" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SORT= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool SORT= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
|
|
$as_echo_n "checking for SORT... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$SORT"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SORT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SORT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SORT=$ac_cv_path_SORT
|
|
if test -n "$SORT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
|
|
$as_echo "$SORT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$SORT" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
|
|
$as_echo_n "checking for SORT... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$SORT" = x; then
|
|
as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${TAIL+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in tail
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TAIL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TAIL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TAIL=$ac_cv_path_TAIL
|
|
if test -n "$TAIL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
|
|
$as_echo "$TAIL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TAIL" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !TAIL! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xTAIL" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in tail
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TAIL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TAIL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TAIL=$ac_cv_path_TAIL
|
|
if test -n "$TAIL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
|
|
$as_echo "$TAIL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TAIL" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$TAIL" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAIL= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool TAIL= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
|
|
$as_echo_n "checking for TAIL... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$TAIL"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TAIL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TAIL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TAIL=$ac_cv_path_TAIL
|
|
if test -n "$TAIL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
|
|
$as_echo "$TAIL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$TAIL" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
|
|
$as_echo_n "checking for TAIL... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TAIL" = x; then
|
|
as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${TAR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in gtar tar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TAR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TAR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TAR=$ac_cv_path_TAR
|
|
if test -n "$TAR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
|
|
$as_echo "$TAR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TAR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !TAR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xTAR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in gtar tar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TAR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TAR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TAR=$ac_cv_path_TAR
|
|
if test -n "$TAR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
|
|
$as_echo "$TAR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TAR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$TAR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TAR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool TAR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
|
|
$as_echo_n "checking for TAR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$TAR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TAR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TAR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TAR=$ac_cv_path_TAR
|
|
if test -n "$TAR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
|
|
$as_echo "$TAR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$TAR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
|
|
$as_echo_n "checking for TAR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TAR" = x; then
|
|
as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${TEE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in tee
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TEE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TEE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TEE=$ac_cv_path_TEE
|
|
if test -n "$TEE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
|
|
$as_echo "$TEE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TEE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !TEE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xTEE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in tee
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TEE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TEE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TEE=$ac_cv_path_TEE
|
|
if test -n "$TEE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
|
|
$as_echo "$TEE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TEE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$TEE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TEE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool TEE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
|
|
$as_echo_n "checking for TEE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$TEE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TEE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TEE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TEE=$ac_cv_path_TEE
|
|
if test -n "$TEE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
|
|
$as_echo "$TEE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$TEE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
|
|
$as_echo_n "checking for TEE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TEE" = x; then
|
|
as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${TOUCH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in touch
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TOUCH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TOUCH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TOUCH=$ac_cv_path_TOUCH
|
|
if test -n "$TOUCH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
|
|
$as_echo "$TOUCH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TOUCH" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !TOUCH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xTOUCH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in touch
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TOUCH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TOUCH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TOUCH=$ac_cv_path_TOUCH
|
|
if test -n "$TOUCH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
|
|
$as_echo "$TOUCH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TOUCH" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$TOUCH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TOUCH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool TOUCH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
|
|
$as_echo_n "checking for TOUCH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$TOUCH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TOUCH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TOUCH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TOUCH=$ac_cv_path_TOUCH
|
|
if test -n "$TOUCH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
|
|
$as_echo "$TOUCH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$TOUCH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
|
|
$as_echo_n "checking for TOUCH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TOUCH" = x; then
|
|
as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${TR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in tr
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TR="$TR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TR=$ac_cv_path_TR
|
|
if test -n "$TR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
|
|
$as_echo "$TR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !TR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xTR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in tr
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TR="$TR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TR=$ac_cv_path_TR
|
|
if test -n "$TR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
|
|
$as_echo "$TR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$TR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool TR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
|
|
$as_echo_n "checking for TR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$TR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TR="$TR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TR=$ac_cv_path_TR
|
|
if test -n "$TR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
|
|
$as_echo "$TR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$TR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
|
|
$as_echo_n "checking for TR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TR" = x; then
|
|
as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${UNAME+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in uname
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNAME=$ac_cv_path_UNAME
|
|
if test -n "$UNAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
|
|
$as_echo "$UNAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$UNAME" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !UNAME! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xUNAME" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in uname
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNAME=$ac_cv_path_UNAME
|
|
if test -n "$UNAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
|
|
$as_echo "$UNAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$UNAME" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$UNAME" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNAME= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool UNAME= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
|
|
$as_echo_n "checking for UNAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$UNAME"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNAME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNAME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNAME=$ac_cv_path_UNAME
|
|
if test -n "$UNAME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
|
|
$as_echo "$UNAME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$UNAME" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
|
|
$as_echo_n "checking for UNAME... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$UNAME" = x; then
|
|
as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${UNIQ+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in uniq
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNIQ+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNIQ in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNIQ=$ac_cv_path_UNIQ
|
|
if test -n "$UNIQ"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
|
|
$as_echo "$UNIQ" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$UNIQ" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !UNIQ! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xUNIQ" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in uniq
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNIQ+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNIQ in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNIQ=$ac_cv_path_UNIQ
|
|
if test -n "$UNIQ"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
|
|
$as_echo "$UNIQ" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$UNIQ" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$UNIQ" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNIQ= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool UNIQ= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
|
|
$as_echo_n "checking for UNIQ... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$UNIQ"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNIQ+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNIQ in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNIQ=$ac_cv_path_UNIQ
|
|
if test -n "$UNIQ"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
|
|
$as_echo "$UNIQ" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$UNIQ" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
|
|
$as_echo_n "checking for UNIQ... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$UNIQ" = x; then
|
|
as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${WC+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in wc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_WC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $WC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_WC="$WC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
WC=$ac_cv_path_WC
|
|
if test -n "$WC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
|
|
$as_echo "$WC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$WC" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !WC! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xWC" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in wc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_WC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $WC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_WC="$WC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
WC=$ac_cv_path_WC
|
|
if test -n "$WC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
|
|
$as_echo "$WC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$WC" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$WC" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WC= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool WC= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
|
|
$as_echo_n "checking for WC... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$WC"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_WC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $WC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_WC="$WC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
WC=$ac_cv_path_WC
|
|
if test -n "$WC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
|
|
$as_echo "$WC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$WC" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
|
|
$as_echo_n "checking for WC... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$WC" = x; then
|
|
as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${WHICH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in which
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_WHICH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $WHICH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
WHICH=$ac_cv_path_WHICH
|
|
if test -n "$WHICH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
|
|
$as_echo "$WHICH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$WHICH" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !WHICH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xWHICH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in which
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_WHICH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $WHICH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
WHICH=$ac_cv_path_WHICH
|
|
if test -n "$WHICH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
|
|
$as_echo "$WHICH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$WHICH" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$WHICH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool WHICH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool WHICH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
|
|
$as_echo_n "checking for WHICH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$WHICH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_WHICH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $WHICH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
WHICH=$ac_cv_path_WHICH
|
|
if test -n "$WHICH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
|
|
$as_echo "$WHICH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$WHICH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
|
|
$as_echo_n "checking for WHICH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$WHICH" = x; then
|
|
as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${XARGS+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in xargs
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XARGS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XARGS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
XARGS=$ac_cv_path_XARGS
|
|
if test -n "$XARGS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
|
|
$as_echo "$XARGS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$XARGS" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !XARGS! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xXARGS" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in xargs
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XARGS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XARGS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
XARGS=$ac_cv_path_XARGS
|
|
if test -n "$XARGS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
|
|
$as_echo "$XARGS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$XARGS" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$XARGS" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XARGS= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool XARGS= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
|
|
$as_echo_n "checking for XARGS... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$XARGS"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XARGS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XARGS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
XARGS=$ac_cv_path_XARGS
|
|
if test -n "$XARGS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
|
|
$as_echo "$XARGS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$XARGS" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
|
|
$as_echo_n "checking for XARGS... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$XARGS" = x; then
|
|
as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Then required tools that require some special treatment.
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${AWK+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in gawk mawk nawk awk
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AWK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AWK"; then
|
|
ac_cv_prog_AWK="$AWK" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AWK="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AWK=$ac_cv_prog_AWK
|
|
if test -n "$AWK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
|
|
$as_echo "$AWK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AWK" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !AWK! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xAWK" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in gawk mawk nawk awk
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AWK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AWK"; then
|
|
ac_cv_prog_AWK="$AWK" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AWK="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AWK=$ac_cv_prog_AWK
|
|
if test -n "$AWK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
|
|
$as_echo "$AWK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AWK" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$AWK" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AWK= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool AWK= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
|
|
$as_echo_n "checking for AWK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$AWK"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_AWK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $AWK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
AWK=$ac_cv_path_AWK
|
|
if test -n "$AWK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
|
|
$as_echo "$AWK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$AWK" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
|
|
$as_echo_n "checking for AWK... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$AWK" = x; then
|
|
as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${GREP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
|
|
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
|
|
if ${ac_cv_path_GREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -z "$GREP"; then
|
|
ac_path_GREP_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in grep ggrep; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_GREP" || continue
|
|
# Check for GNU ac_path_GREP and select it if it is found.
|
|
# Check for GNU $ac_path_GREP
|
|
case `"$ac_path_GREP" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo 'GREP' >> "conftest.nl"
|
|
"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_GREP_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_GREP="$ac_path_GREP"
|
|
ac_path_GREP_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_GREP_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_GREP"; then
|
|
as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_GREP=$GREP
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
|
|
$as_echo "$ac_cv_path_GREP" >&6; }
|
|
GREP="$ac_cv_path_GREP"
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !GREP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xGREP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
|
|
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
|
|
if ${ac_cv_path_GREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -z "$GREP"; then
|
|
ac_path_GREP_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in grep ggrep; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_GREP" || continue
|
|
# Check for GNU ac_path_GREP and select it if it is found.
|
|
# Check for GNU $ac_path_GREP
|
|
case `"$ac_path_GREP" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo 'GREP' >> "conftest.nl"
|
|
"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_GREP_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_GREP="$ac_path_GREP"
|
|
ac_path_GREP_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_GREP_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_GREP"; then
|
|
as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_GREP=$GREP
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
|
|
$as_echo "$ac_cv_path_GREP" >&6; }
|
|
GREP="$ac_cv_path_GREP"
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$GREP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GREP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool GREP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
|
|
$as_echo_n "checking for GREP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$GREP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GREP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GREP=$ac_cv_path_GREP
|
|
if test -n "$GREP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
|
|
$as_echo "$GREP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$GREP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
|
|
$as_echo_n "checking for GREP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$GREP" = x; then
|
|
as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${EGREP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
|
|
$as_echo_n "checking for egrep... " >&6; }
|
|
if ${ac_cv_path_EGREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
|
|
then ac_cv_path_EGREP="$GREP -E"
|
|
else
|
|
if test -z "$EGREP"; then
|
|
ac_path_EGREP_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in egrep; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_EGREP" || continue
|
|
# Check for GNU ac_path_EGREP and select it if it is found.
|
|
# Check for GNU $ac_path_EGREP
|
|
case `"$ac_path_EGREP" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo 'EGREP' >> "conftest.nl"
|
|
"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_EGREP_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_EGREP="$ac_path_EGREP"
|
|
ac_path_EGREP_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_EGREP_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_EGREP"; then
|
|
as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_EGREP=$EGREP
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
|
|
$as_echo "$ac_cv_path_EGREP" >&6; }
|
|
EGREP="$ac_cv_path_EGREP"
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !EGREP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xEGREP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
|
|
$as_echo_n "checking for egrep... " >&6; }
|
|
if ${ac_cv_path_EGREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
|
|
then ac_cv_path_EGREP="$GREP -E"
|
|
else
|
|
if test -z "$EGREP"; then
|
|
ac_path_EGREP_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in egrep; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_EGREP" || continue
|
|
# Check for GNU ac_path_EGREP and select it if it is found.
|
|
# Check for GNU $ac_path_EGREP
|
|
case `"$ac_path_EGREP" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo 'EGREP' >> "conftest.nl"
|
|
"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_EGREP_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_EGREP="$ac_path_EGREP"
|
|
ac_path_EGREP_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_EGREP_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_EGREP"; then
|
|
as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_EGREP=$EGREP
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
|
|
$as_echo "$ac_cv_path_EGREP" >&6; }
|
|
EGREP="$ac_cv_path_EGREP"
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$EGREP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool EGREP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool EGREP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
|
|
$as_echo_n "checking for EGREP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$EGREP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_EGREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $EGREP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
EGREP=$ac_cv_path_EGREP
|
|
if test -n "$EGREP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
|
|
$as_echo "$EGREP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$EGREP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
|
|
$as_echo_n "checking for EGREP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$EGREP" = x; then
|
|
as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${FGREP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
|
|
$as_echo_n "checking for fgrep... " >&6; }
|
|
if ${ac_cv_path_FGREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
|
|
then ac_cv_path_FGREP="$GREP -F"
|
|
else
|
|
if test -z "$FGREP"; then
|
|
ac_path_FGREP_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in fgrep; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_FGREP" || continue
|
|
# Check for GNU ac_path_FGREP and select it if it is found.
|
|
# Check for GNU $ac_path_FGREP
|
|
case `"$ac_path_FGREP" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo 'FGREP' >> "conftest.nl"
|
|
"$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_FGREP_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_FGREP="$ac_path_FGREP"
|
|
ac_path_FGREP_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_FGREP_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_FGREP"; then
|
|
as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_FGREP=$FGREP
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
|
|
$as_echo "$ac_cv_path_FGREP" >&6; }
|
|
FGREP="$ac_cv_path_FGREP"
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !FGREP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xFGREP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
|
|
$as_echo_n "checking for fgrep... " >&6; }
|
|
if ${ac_cv_path_FGREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
|
|
then ac_cv_path_FGREP="$GREP -F"
|
|
else
|
|
if test -z "$FGREP"; then
|
|
ac_path_FGREP_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in fgrep; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_FGREP" || continue
|
|
# Check for GNU ac_path_FGREP and select it if it is found.
|
|
# Check for GNU $ac_path_FGREP
|
|
case `"$ac_path_FGREP" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo 'FGREP' >> "conftest.nl"
|
|
"$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_FGREP_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_FGREP="$ac_path_FGREP"
|
|
ac_path_FGREP_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_FGREP_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_FGREP"; then
|
|
as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_FGREP=$FGREP
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
|
|
$as_echo "$ac_cv_path_FGREP" >&6; }
|
|
FGREP="$ac_cv_path_FGREP"
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$FGREP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FGREP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool FGREP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
|
|
$as_echo_n "checking for FGREP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$FGREP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FGREP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FGREP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FGREP=$ac_cv_path_FGREP
|
|
if test -n "$FGREP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
|
|
$as_echo "$FGREP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$FGREP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
|
|
$as_echo_n "checking for FGREP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$FGREP" = x; then
|
|
as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${SED+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
|
|
$as_echo_n "checking for a sed that does not truncate output... " >&6; }
|
|
if ${ac_cv_path_SED+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
|
|
for ac_i in 1 2 3 4 5 6 7; do
|
|
ac_script="$ac_script$as_nl$ac_script"
|
|
done
|
|
echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
|
|
{ ac_script=; unset ac_script;}
|
|
if test -z "$SED"; then
|
|
ac_path_SED_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in sed gsed; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_SED" || continue
|
|
# Check for GNU ac_path_SED and select it if it is found.
|
|
# Check for GNU $ac_path_SED
|
|
case `"$ac_path_SED" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo '' >> "conftest.nl"
|
|
"$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_SED_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_SED="$ac_path_SED"
|
|
ac_path_SED_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_SED_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_SED"; then
|
|
as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_SED=$SED
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
|
|
$as_echo "$ac_cv_path_SED" >&6; }
|
|
SED="$ac_cv_path_SED"
|
|
rm -f conftest.sed
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !SED! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSED" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
|
|
$as_echo_n "checking for a sed that does not truncate output... " >&6; }
|
|
if ${ac_cv_path_SED+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
|
|
for ac_i in 1 2 3 4 5 6 7; do
|
|
ac_script="$ac_script$as_nl$ac_script"
|
|
done
|
|
echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
|
|
{ ac_script=; unset ac_script;}
|
|
if test -z "$SED"; then
|
|
ac_path_SED_found=false
|
|
# Loop through the user's path and test for each of PROGNAME-LIST
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_prog in sed gsed; do
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
|
|
as_fn_executable_p "$ac_path_SED" || continue
|
|
# Check for GNU ac_path_SED and select it if it is found.
|
|
# Check for GNU $ac_path_SED
|
|
case `"$ac_path_SED" --version 2>&1` in
|
|
*GNU*)
|
|
ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
|
|
*)
|
|
ac_count=0
|
|
$as_echo_n 0123456789 >"conftest.in"
|
|
while :
|
|
do
|
|
cat "conftest.in" "conftest.in" >"conftest.tmp"
|
|
mv "conftest.tmp" "conftest.in"
|
|
cp "conftest.in" "conftest.nl"
|
|
$as_echo '' >> "conftest.nl"
|
|
"$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
|
|
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
|
|
as_fn_arith $ac_count + 1 && ac_count=$as_val
|
|
if test $ac_count -gt ${ac_path_SED_max-0}; then
|
|
# Best one so far, save it but keep looking for a better one
|
|
ac_cv_path_SED="$ac_path_SED"
|
|
ac_path_SED_max=$ac_count
|
|
fi
|
|
# 10*(2^10) chars as input seems more than enough
|
|
test $ac_count -gt 10 && break
|
|
done
|
|
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
|
|
esac
|
|
|
|
$ac_path_SED_found && break 3
|
|
done
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
if test -z "$ac_cv_path_SED"; then
|
|
as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
|
|
fi
|
|
else
|
|
ac_cv_path_SED=$SED
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
|
|
$as_echo "$ac_cv_path_SED" >&6; }
|
|
SED="$ac_cv_path_SED"
|
|
rm -f conftest.sed
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$SED" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SED= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool SED= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
|
|
$as_echo_n "checking for SED... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$SED"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SED+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SED in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SED="$SED" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SED=$ac_cv_path_SED
|
|
if test -n "$SED"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
|
|
$as_echo "$SED" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$SED" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
|
|
$as_echo_n "checking for SED... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$SED" = x; then
|
|
as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Always force rm.
|
|
RM="$RM -f"
|
|
|
|
# pwd behaves differently on various platforms and some don't support the -L flag.
|
|
# Always use the bash builtin pwd to get uniform behavior.
|
|
THEPWDCMD=pwd
|
|
|
|
# These are not required on all platforms
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CYGPATH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cygpath
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CYGPATH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CYGPATH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CYGPATH=$ac_cv_path_CYGPATH
|
|
if test -n "$CYGPATH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
|
|
$as_echo "$CYGPATH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CYGPATH" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CYGPATH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCYGPATH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cygpath
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CYGPATH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CYGPATH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CYGPATH=$ac_cv_path_CYGPATH
|
|
if test -n "$CYGPATH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
|
|
$as_echo "$CYGPATH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CYGPATH" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CYGPATH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CYGPATH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CYGPATH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
|
|
$as_echo_n "checking for CYGPATH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CYGPATH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CYGPATH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CYGPATH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CYGPATH=$ac_cv_path_CYGPATH
|
|
if test -n "$CYGPATH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
|
|
$as_echo "$CYGPATH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CYGPATH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
|
|
$as_echo_n "checking for CYGPATH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${READLINK+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in greadlink readlink
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_READLINK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $READLINK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
READLINK=$ac_cv_path_READLINK
|
|
if test -n "$READLINK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
|
|
$as_echo "$READLINK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$READLINK" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !READLINK! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xREADLINK" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in greadlink readlink
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_READLINK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $READLINK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
READLINK=$ac_cv_path_READLINK
|
|
if test -n "$READLINK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
|
|
$as_echo "$READLINK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$READLINK" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$READLINK" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READLINK= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool READLINK= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
|
|
$as_echo_n "checking for READLINK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$READLINK"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_READLINK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $READLINK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
READLINK=$ac_cv_path_READLINK
|
|
if test -n "$READLINK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
|
|
$as_echo "$READLINK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$READLINK" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
|
|
$as_echo_n "checking for READLINK... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DF+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in df
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DF="$DF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DF=$ac_cv_path_DF
|
|
if test -n "$DF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
|
|
$as_echo "$DF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DF" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DF! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDF" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in df
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DF="$DF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DF=$ac_cv_path_DF
|
|
if test -n "$DF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
|
|
$as_echo "$DF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DF" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DF" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DF= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DF= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
|
|
$as_echo_n "checking for DF... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DF"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DF="$DF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DF=$ac_cv_path_DF
|
|
if test -n "$DF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
|
|
$as_echo "$DF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DF" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
|
|
$as_echo_n "checking for DF... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CPIO+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cpio bsdcpio
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CPIO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CPIO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CPIO=$ac_cv_path_CPIO
|
|
if test -n "$CPIO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
|
|
$as_echo "$CPIO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CPIO" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CPIO! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCPIO" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cpio bsdcpio
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CPIO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CPIO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CPIO=$ac_cv_path_CPIO
|
|
if test -n "$CPIO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
|
|
$as_echo "$CPIO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CPIO" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CPIO" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CPIO= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CPIO= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
|
|
$as_echo_n "checking for CPIO... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CPIO"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CPIO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CPIO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CPIO=$ac_cv_path_CPIO
|
|
if test -n "$CPIO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
|
|
$as_echo "$CPIO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CPIO" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
|
|
$as_echo_n "checking for CPIO... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${NICE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in nice
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NICE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NICE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NICE=$ac_cv_path_NICE
|
|
if test -n "$NICE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
|
|
$as_echo "$NICE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NICE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !NICE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NICE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xNICE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of NICE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in nice
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NICE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NICE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NICE=$ac_cv_path_NICE
|
|
if test -n "$NICE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
|
|
$as_echo "$NICE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NICE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$NICE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NICE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool NICE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
|
|
$as_echo_n "checking for NICE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$NICE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NICE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool NICE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NICE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NICE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NICE="$NICE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NICE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NICE=$ac_cv_path_NICE
|
|
if test -n "$NICE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NICE" >&5
|
|
$as_echo "$NICE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$NICE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NICE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool NICE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NICE" >&5
|
|
$as_echo_n "checking for NICE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool NICE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${PANDOC+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in pandoc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PANDOC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PANDOC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PANDOC=$ac_cv_path_PANDOC
|
|
if test -n "$PANDOC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
|
|
$as_echo "$PANDOC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PANDOC" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !PANDOC! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PANDOC!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xPANDOC" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in pandoc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PANDOC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PANDOC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PANDOC=$ac_cv_path_PANDOC
|
|
if test -n "$PANDOC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
|
|
$as_echo "$PANDOC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PANDOC" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$PANDOC" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PANDOC= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool PANDOC= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PANDOC" >&5
|
|
$as_echo_n "checking for PANDOC... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$PANDOC"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PANDOC=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool PANDOC=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PANDOC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PANDOC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PANDOC=$ac_cv_path_PANDOC
|
|
if test -n "$PANDOC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
|
|
$as_echo "$PANDOC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$PANDOC" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PANDOC=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool PANDOC=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PANDOC" >&5
|
|
$as_echo_n "checking for PANDOC... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool PANDOC=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Now we can determine OpenJDK build and target platforms. This is required to
|
|
# have early on.
|
|
# Make sure we can run config.sub.
|
|
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
|
|
as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
|
|
$as_echo_n "checking build system type... " >&6; }
|
|
if ${ac_cv_build+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_build_alias=$build_alias
|
|
test "x$ac_build_alias" = x &&
|
|
ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
|
|
test "x$ac_build_alias" = x &&
|
|
as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
|
|
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
|
|
as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
|
|
$as_echo "$ac_cv_build" >&6; }
|
|
case $ac_cv_build in
|
|
*-*-*) ;;
|
|
*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
|
|
esac
|
|
build=$ac_cv_build
|
|
ac_save_IFS=$IFS; IFS='-'
|
|
set x $ac_cv_build
|
|
shift
|
|
build_cpu=$1
|
|
build_vendor=$2
|
|
shift; shift
|
|
# Remember, the first character of IFS is used to create $*,
|
|
# except with old shells:
|
|
build_os=$*
|
|
IFS=$ac_save_IFS
|
|
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
|
|
$as_echo_n "checking host system type... " >&6; }
|
|
if ${ac_cv_host+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test "x$host_alias" = x; then
|
|
ac_cv_host=$ac_cv_build
|
|
else
|
|
ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
|
|
as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
|
|
$as_echo "$ac_cv_host" >&6; }
|
|
case $ac_cv_host in
|
|
*-*-*) ;;
|
|
*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
|
|
esac
|
|
host=$ac_cv_host
|
|
ac_save_IFS=$IFS; IFS='-'
|
|
set x $ac_cv_host
|
|
shift
|
|
host_cpu=$1
|
|
host_vendor=$2
|
|
shift; shift
|
|
# Remember, the first character of IFS is used to create $*,
|
|
# except with old shells:
|
|
host_os=$*
|
|
IFS=$ac_save_IFS
|
|
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
|
|
$as_echo_n "checking target system type... " >&6; }
|
|
if ${ac_cv_target+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test "x$target_alias" = x; then
|
|
ac_cv_target=$ac_cv_host
|
|
else
|
|
ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
|
|
as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
|
|
$as_echo "$ac_cv_target" >&6; }
|
|
case $ac_cv_target in
|
|
*-*-*) ;;
|
|
*) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
|
|
esac
|
|
target=$ac_cv_target
|
|
ac_save_IFS=$IFS; IFS='-'
|
|
set x $ac_cv_target
|
|
shift
|
|
target_cpu=$1
|
|
target_vendor=$2
|
|
shift; shift
|
|
# Remember, the first character of IFS is used to create $*,
|
|
# except with old shells:
|
|
target_os=$*
|
|
IFS=$ac_save_IFS
|
|
case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
|
|
|
|
|
|
# The aliases save the names the user supplied, while $host etc.
|
|
# will get canonicalized.
|
|
test -n "$target_alias" &&
|
|
test "$program_prefix$program_suffix$program_transform_name" = \
|
|
NONENONEs,x,x, &&
|
|
program_prefix=${target_alias}-
|
|
|
|
# Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
|
|
# is confusing; it assumes you are cross-compiling a cross-compiler (!) and "target" is thus the target of the
|
|
# product you're building. The target of this build is called "host". Since this is confusing to most people, we
|
|
# have not adopted that system, but use "target" as the platform we are building for. In some places though we need
|
|
# to use the configure naming style.
|
|
|
|
|
|
|
|
|
|
|
|
# Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
|
|
# (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
|
|
# Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
|
|
# but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
|
|
OPENJDK_TARGET_AUTOCONF_NAME="$host"
|
|
OPENJDK_BUILD_AUTOCONF_NAME="$build"
|
|
|
|
|
|
|
|
# Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
|
|
|
|
case "$build_os" in
|
|
*linux*)
|
|
VAR_OS=linux
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*solaris*)
|
|
VAR_OS=solaris
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*darwin*)
|
|
VAR_OS=macosx
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*bsd*)
|
|
VAR_OS=bsd
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*cygwin*)
|
|
VAR_OS=windows
|
|
VAR_OS_ENV=windows.cygwin
|
|
;;
|
|
*mingw*)
|
|
VAR_OS=windows
|
|
VAR_OS_ENV=windows.msys
|
|
;;
|
|
*aix*)
|
|
VAR_OS=aix
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*)
|
|
as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
|
|
;;
|
|
esac
|
|
|
|
|
|
# First argument is the cpu name from the trip/quad
|
|
case "$build_cpu" in
|
|
x86_64)
|
|
VAR_CPU=x86_64
|
|
VAR_CPU_ARCH=x86
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
i?86)
|
|
VAR_CPU=x86
|
|
VAR_CPU_ARCH=x86
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
alpha*)
|
|
VAR_CPU=alpha
|
|
VAR_CPU_ARCH=alpha
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
arm*)
|
|
VAR_CPU=arm
|
|
VAR_CPU_ARCH=arm
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
aarch64)
|
|
VAR_CPU=aarch64
|
|
VAR_CPU_ARCH=aarch64
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
m68k)
|
|
VAR_CPU=m68k
|
|
VAR_CPU_ARCH=m68k
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
mips)
|
|
VAR_CPU=mips
|
|
VAR_CPU_ARCH=mips
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
mipsel)
|
|
VAR_CPU=mipsel
|
|
VAR_CPU_ARCH=mipsel
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
mips64)
|
|
VAR_CPU=mips64
|
|
VAR_CPU_ARCH=mips64
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
mips64el)
|
|
VAR_CPU=mips64el
|
|
VAR_CPU_ARCH=mips64el
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
powerpc)
|
|
VAR_CPU=ppc
|
|
VAR_CPU_ARCH=ppc
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
powerpc64)
|
|
VAR_CPU=ppc64
|
|
VAR_CPU_ARCH=ppc
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
powerpc64le)
|
|
VAR_CPU=ppc64le
|
|
VAR_CPU_ARCH=ppc
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
s390)
|
|
VAR_CPU=s390
|
|
VAR_CPU_ARCH=s390
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
s390x)
|
|
VAR_CPU=s390x
|
|
VAR_CPU_ARCH=s390
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
sh*eb)
|
|
VAR_CPU=sh
|
|
VAR_CPU_ARCH=sh
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
sh*)
|
|
VAR_CPU=sh
|
|
VAR_CPU_ARCH=sh
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
sparc)
|
|
VAR_CPU=sparc
|
|
VAR_CPU_ARCH=sparc
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
sparcv9|sparc64)
|
|
VAR_CPU=sparcv9
|
|
VAR_CPU_ARCH=sparc
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
*)
|
|
as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
|
|
;;
|
|
esac
|
|
|
|
# ..and setup our own variables. (Do this explicitly to facilitate searching)
|
|
OPENJDK_BUILD_OS="$VAR_OS"
|
|
if test "x$VAR_OS_TYPE" != x; then
|
|
OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
|
|
else
|
|
OPENJDK_BUILD_OS_TYPE="$VAR_OS"
|
|
fi
|
|
if test "x$VAR_OS_ENV" != x; then
|
|
OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
|
|
else
|
|
OPENJDK_BUILD_OS_ENV="$VAR_OS"
|
|
fi
|
|
OPENJDK_BUILD_CPU="$VAR_CPU"
|
|
OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
|
|
OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
|
|
OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
|
|
$as_echo_n "checking openjdk-build os-cpu... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
|
|
$as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
|
|
|
|
# Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
|
|
|
|
case "$host_os" in
|
|
*linux*)
|
|
VAR_OS=linux
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*solaris*)
|
|
VAR_OS=solaris
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*darwin*)
|
|
VAR_OS=macosx
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*bsd*)
|
|
VAR_OS=bsd
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*cygwin*)
|
|
VAR_OS=windows
|
|
VAR_OS_ENV=windows.cygwin
|
|
;;
|
|
*mingw*)
|
|
VAR_OS=windows
|
|
VAR_OS_ENV=windows.msys
|
|
;;
|
|
*aix*)
|
|
VAR_OS=aix
|
|
VAR_OS_TYPE=unix
|
|
;;
|
|
*)
|
|
as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
|
|
;;
|
|
esac
|
|
|
|
|
|
# First argument is the cpu name from the trip/quad
|
|
case "$host_cpu" in
|
|
x86_64)
|
|
VAR_CPU=x86_64
|
|
VAR_CPU_ARCH=x86
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
i?86)
|
|
VAR_CPU=x86
|
|
VAR_CPU_ARCH=x86
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
alpha*)
|
|
VAR_CPU=alpha
|
|
VAR_CPU_ARCH=alpha
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
arm*)
|
|
VAR_CPU=arm
|
|
VAR_CPU_ARCH=arm
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
aarch64)
|
|
VAR_CPU=aarch64
|
|
VAR_CPU_ARCH=aarch64
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
m68k)
|
|
VAR_CPU=m68k
|
|
VAR_CPU_ARCH=m68k
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
mips)
|
|
VAR_CPU=mips
|
|
VAR_CPU_ARCH=mips
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
mipsel)
|
|
VAR_CPU=mipsel
|
|
VAR_CPU_ARCH=mipsel
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
mips64)
|
|
VAR_CPU=mips64
|
|
VAR_CPU_ARCH=mips64
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
mips64el)
|
|
VAR_CPU=mips64el
|
|
VAR_CPU_ARCH=mips64el
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
powerpc)
|
|
VAR_CPU=ppc
|
|
VAR_CPU_ARCH=ppc
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
powerpc64)
|
|
VAR_CPU=ppc64
|
|
VAR_CPU_ARCH=ppc
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
powerpc64le)
|
|
VAR_CPU=ppc64le
|
|
VAR_CPU_ARCH=ppc
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
s390)
|
|
VAR_CPU=s390
|
|
VAR_CPU_ARCH=s390
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
s390x)
|
|
VAR_CPU=s390x
|
|
VAR_CPU_ARCH=s390
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
sh*eb)
|
|
VAR_CPU=sh
|
|
VAR_CPU_ARCH=sh
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
sh*)
|
|
VAR_CPU=sh
|
|
VAR_CPU_ARCH=sh
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=little
|
|
;;
|
|
sparc)
|
|
VAR_CPU=sparc
|
|
VAR_CPU_ARCH=sparc
|
|
VAR_CPU_BITS=32
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
sparcv9|sparc64)
|
|
VAR_CPU=sparcv9
|
|
VAR_CPU_ARCH=sparc
|
|
VAR_CPU_BITS=64
|
|
VAR_CPU_ENDIAN=big
|
|
;;
|
|
*)
|
|
as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
|
|
;;
|
|
esac
|
|
|
|
# ... and setup our own variables. (Do this explicitly to facilitate searching)
|
|
OPENJDK_TARGET_OS="$VAR_OS"
|
|
if test "x$VAR_OS_TYPE" != x; then
|
|
OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
|
|
else
|
|
OPENJDK_TARGET_OS_TYPE="$VAR_OS"
|
|
fi
|
|
if test "x$VAR_OS_ENV" != x; then
|
|
OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
|
|
else
|
|
OPENJDK_TARGET_OS_ENV="$VAR_OS"
|
|
fi
|
|
OPENJDK_TARGET_CPU="$VAR_CPU"
|
|
OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
|
|
OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
|
|
OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
|
|
$as_echo_n "checking openjdk-target os-cpu... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
|
|
$as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
|
|
|
|
|
|
|
|
# Check whether --with-target-bits was given.
|
|
if test "${with_target_bits+set}" = set; then :
|
|
withval=$with_target_bits;
|
|
fi
|
|
|
|
|
|
# We have three types of compiles:
|
|
# native == normal compilation, target system == build system
|
|
# cross == traditional cross compilation, target system != build system; special toolchain needed
|
|
# reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
|
|
#
|
|
if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
|
|
# We're doing a proper cross-compilation
|
|
COMPILE_TYPE="cross"
|
|
else
|
|
COMPILE_TYPE="native"
|
|
fi
|
|
|
|
if test "x$with_target_bits" != x; then
|
|
if test "x$COMPILE_TYPE" = "xcross"; then
|
|
as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
|
|
fi
|
|
|
|
if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
# A reduced build is requested
|
|
COMPILE_TYPE="reduced"
|
|
OPENJDK_TARGET_CPU_BITS=32
|
|
if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
|
|
OPENJDK_TARGET_CPU=x86
|
|
elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
|
|
OPENJDK_TARGET_CPU=sparc
|
|
else
|
|
as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
|
|
fi
|
|
elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
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
|
|
elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
|
|
$as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
|
|
else
|
|
as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
|
|
$as_echo_n "checking compilation type... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
|
|
$as_echo "$COMPILE_TYPE" >&6; }
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
OPENJDK_MODULE_TARGET_OS_NAME="macos"
|
|
else
|
|
OPENJDK_MODULE_TARGET_OS_NAME="$OPENJDK_TARGET_OS"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
OPENJDK_MODULE_TARGET_OS_ARCH="amd64"
|
|
else
|
|
OPENJDK_MODULE_TARGET_OS_ARCH="$OPENJDK_TARGET_CPU"
|
|
fi
|
|
|
|
OPENJDK_MODULE_TARGET_PLATFORM="${OPENJDK_MODULE_TARGET_OS_NAME}-${OPENJDK_MODULE_TARGET_OS_ARCH}"
|
|
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
|
|
RELEASE_FILE_OS_NAME=SunOS
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
|
|
RELEASE_FILE_OS_NAME=Linux
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
|
|
RELEASE_FILE_OS_NAME=Windows
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
RELEASE_FILE_OS_NAME="Darwin"
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = "xaix"; then
|
|
RELEASE_FILE_OS_NAME="AIX"
|
|
fi
|
|
RELEASE_FILE_OS_ARCH=${OPENJDK_TARGET_CPU}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Also store the legacy naming of the cpu.
|
|
# Ie i586 and amd64 instead of x86 and x86_64
|
|
OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
OPENJDK_TARGET_CPU_LEGACY="i586"
|
|
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
# On all platforms except MacOSX replace x86_64 with amd64.
|
|
OPENJDK_TARGET_CPU_LEGACY="amd64"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xalpha; then
|
|
# Avoid name collisions with variables named alpha
|
|
OPENJDK_TARGET_CPU_LEGACY="_alpha_"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xsh; then
|
|
# Avoid name collisions with variables named sh
|
|
OPENJDK_TARGET_CPU_LEGACY="_sh_"
|
|
fi
|
|
|
|
|
|
# And the second legacy naming of the cpu.
|
|
# Ie i386 and amd64 instead of x86 and x86_64.
|
|
OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
|
|
fi
|
|
|
|
|
|
# OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
|
|
# /amd64 or /sparcv9. This string is appended to some library paths, like this:
|
|
# /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
|
|
OPENJDK_TARGET_CPU_ISADIR=""
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
OPENJDK_TARGET_CPU_ISADIR="/amd64"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
|
|
OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
|
|
OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
# On linux only, we replace x86 with i386.
|
|
OPENJDK_TARGET_CPU_OSARCH="i386"
|
|
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
# On all platforms except macosx, we replace x86_64 with amd64.
|
|
OPENJDK_TARGET_CPU_OSARCH="amd64"
|
|
fi
|
|
|
|
|
|
OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
OPENJDK_TARGET_CPU_JLI="i386"
|
|
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
# On all platforms except macosx, we replace x86_64 with amd64.
|
|
OPENJDK_TARGET_CPU_JLI="amd64"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
OPENJDK_TARGET_OS_EXPORT_DIR=macosx
|
|
else
|
|
OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
|
|
fi
|
|
|
|
|
|
# The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
|
|
# Macosx is osx and x86_64 is x64
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
OPENJDK_TARGET_OS_BUNDLE="osx"
|
|
else
|
|
OPENJDK_TARGET_OS_BUNDLE="$OPENJDK_TARGET_OS"
|
|
fi
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
OPENJDK_TARGET_CPU_BUNDLE="x64"
|
|
else
|
|
OPENJDK_TARGET_CPU_BUNDLE="$OPENJDK_TARGET_CPU"
|
|
fi
|
|
OPENJDK_TARGET_BUNDLE_PLATFORM="${OPENJDK_TARGET_OS_BUNDLE}-${OPENJDK_TARGET_CPU_BUNDLE}"
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
# -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
|
|
# unpack200.exe. This variable is used in
|
|
# FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER.
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
OPENJDK_TARGET_ADD_LP64="-D_LP64=1"
|
|
fi
|
|
fi
|
|
|
|
if test "x$COMPILE_TYPE" = "xcross"; then
|
|
# FIXME: ... or should this include reduced builds..?
|
|
DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
|
|
else
|
|
DEFINE_CROSS_COMPILE_ARCH=""
|
|
fi
|
|
|
|
|
|
# Convert openjdk platform names to hotspot names
|
|
|
|
HOTSPOT_TARGET_OS=${OPENJDK_TARGET_OS}
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
HOTSPOT_TARGET_OS=bsd
|
|
fi
|
|
|
|
|
|
HOTSPOT_TARGET_OS_TYPE=${OPENJDK_TARGET_OS_TYPE}
|
|
if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
|
|
HOTSPOT_TARGET_OS_TYPE=posix
|
|
fi
|
|
|
|
|
|
HOTSPOT_TARGET_CPU=${OPENJDK_TARGET_CPU}
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
HOTSPOT_TARGET_CPU=x86_32
|
|
elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
|
|
HOTSPOT_TARGET_CPU=sparc
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
|
|
HOTSPOT_TARGET_CPU=ppc_64
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
|
|
HOTSPOT_TARGET_CPU=ppc_64
|
|
fi
|
|
|
|
|
|
# This is identical with OPENJDK_*, but define anyway for consistency.
|
|
HOTSPOT_TARGET_CPU_ARCH=${OPENJDK_TARGET_CPU_ARCH}
|
|
|
|
|
|
# Setup HOTSPOT_TARGET_CPU_DEFINE
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=IA32
|
|
elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=AMD64
|
|
elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=SPARC
|
|
elif test "x$OPENJDK_TARGET_CPU" = xaarch64; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=AARCH64
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=PPC64
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=PPC64
|
|
|
|
# The cpu defines below are for zero, we don't support them directly.
|
|
elif test "x$OPENJDK_TARGET_CPU" = xsparc; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=SPARC
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=PPC32
|
|
elif test "x$OPENJDK_TARGET_CPU" = xs390; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=S390
|
|
elif test "x$OPENJDK_TARGET_CPU" = xs390x; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=S390
|
|
elif test "x$OPENJDK_TARGET_CPU" != x; then
|
|
HOTSPOT_TARGET_CPU_DEFINE=$(echo $OPENJDK_TARGET_CPU | tr a-z A-Z)
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Also store the legacy naming of the cpu.
|
|
# Ie i586 and amd64 instead of x86 and x86_64
|
|
OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
OPENJDK_BUILD_CPU_LEGACY="i586"
|
|
elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
# On all platforms except MacOSX replace x86_64 with amd64.
|
|
OPENJDK_BUILD_CPU_LEGACY="amd64"
|
|
elif test "x$OPENJDK_BUILD_CPU" = xalpha; then
|
|
# Avoid name collisions with variables named alpha
|
|
OPENJDK_BUILD_CPU_LEGACY="_alpha_"
|
|
elif test "x$OPENJDK_BUILD_CPU" = xsh; then
|
|
# Avoid name collisions with variables named sh
|
|
OPENJDK_BUILD_CPU_LEGACY="_sh_"
|
|
fi
|
|
|
|
|
|
# And the second legacy naming of the cpu.
|
|
# Ie i386 and amd64 instead of x86 and x86_64.
|
|
OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
|
|
elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
|
|
fi
|
|
|
|
|
|
# OPENJDK_BUILD_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
|
|
# /amd64 or /sparcv9. This string is appended to some library paths, like this:
|
|
# /usr/lib${OPENJDK_BUILD_CPU_ISADIR}/libexample.so
|
|
OPENJDK_BUILD_CPU_ISADIR=""
|
|
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
OPENJDK_BUILD_CPU_ISADIR="/amd64"
|
|
elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
|
|
OPENJDK_BUILD_CPU_ISADIR="/sparcv9"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Setup OPENJDK_BUILD_CPU_OSARCH, which is used to set the os.arch Java system property
|
|
OPENJDK_BUILD_CPU_OSARCH="$OPENJDK_BUILD_CPU"
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux && test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
# On linux only, we replace x86 with i386.
|
|
OPENJDK_BUILD_CPU_OSARCH="i386"
|
|
elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
# On all platforms except macosx, we replace x86_64 with amd64.
|
|
OPENJDK_BUILD_CPU_OSARCH="amd64"
|
|
fi
|
|
|
|
|
|
OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
OPENJDK_BUILD_CPU_JLI="i386"
|
|
elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
# On all platforms except macosx, we replace x86_64 with amd64.
|
|
OPENJDK_BUILD_CPU_JLI="amd64"
|
|
fi
|
|
|
|
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_OS_EXPORT_DIR=macosx
|
|
else
|
|
OPENJDK_BUILD_OS_EXPORT_DIR=${OPENJDK_BUILD_OS_TYPE}
|
|
fi
|
|
|
|
|
|
# The new version string in JDK 9 also defined new naming of OS and ARCH for bundles
|
|
# Macosx is osx and x86_64 is x64
|
|
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_OS_BUNDLE="osx"
|
|
else
|
|
OPENJDK_BUILD_OS_BUNDLE="$OPENJDK_TARGET_OS"
|
|
fi
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
OPENJDK_BUILD_CPU_BUNDLE="x64"
|
|
else
|
|
OPENJDK_BUILD_CPU_BUNDLE="$OPENJDK_BUILD_CPU"
|
|
fi
|
|
OPENJDK_BUILD_BUNDLE_PLATFORM="${OPENJDK_BUILD_OS_BUNDLE}-${OPENJDK_BUILD_CPU_BUNDLE}"
|
|
|
|
|
|
if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
|
|
# -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
|
|
# unpack200.exe. This variable is used in
|
|
# FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER.
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
|
|
fi
|
|
fi
|
|
|
|
if test "x$COMPILE_TYPE" = "xcross"; then
|
|
# FIXME: ... or should this include reduced builds..?
|
|
DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_BUILD_CPU_LEGACY"
|
|
else
|
|
DEFINE_CROSS_COMPILE_ARCH=""
|
|
fi
|
|
|
|
|
|
# Convert openjdk platform names to hotspot names
|
|
|
|
HOTSPOT_BUILD_OS=${OPENJDK_BUILD_OS}
|
|
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
HOTSPOT_BUILD_OS=bsd
|
|
fi
|
|
|
|
|
|
HOTSPOT_BUILD_OS_TYPE=${OPENJDK_BUILD_OS_TYPE}
|
|
if test "x$OPENJDK_BUILD_OS_TYPE" = xunix; then
|
|
HOTSPOT_BUILD_OS_TYPE=posix
|
|
fi
|
|
|
|
|
|
HOTSPOT_BUILD_CPU=${OPENJDK_BUILD_CPU}
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
HOTSPOT_BUILD_CPU=x86_32
|
|
elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
|
|
HOTSPOT_BUILD_CPU=sparc
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
|
|
HOTSPOT_BUILD_CPU=ppc_64
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
|
|
HOTSPOT_BUILD_CPU=ppc_64
|
|
fi
|
|
|
|
|
|
# This is identical with OPENJDK_*, but define anyway for consistency.
|
|
HOTSPOT_BUILD_CPU_ARCH=${OPENJDK_BUILD_CPU_ARCH}
|
|
|
|
|
|
# Setup HOTSPOT_BUILD_CPU_DEFINE
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=IA32
|
|
elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=AMD64
|
|
elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=SPARC
|
|
elif test "x$OPENJDK_BUILD_CPU" = xaarch64; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=AARCH64
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=PPC64
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=PPC64
|
|
|
|
# The cpu defines below are for zero, we don't support them directly.
|
|
elif test "x$OPENJDK_BUILD_CPU" = xsparc; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=SPARC
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=PPC32
|
|
elif test "x$OPENJDK_BUILD_CPU" = xs390; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=S390
|
|
elif test "x$OPENJDK_BUILD_CPU" = xs390x; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=S390
|
|
elif test "x$OPENJDK_BUILD_CPU" != x; then
|
|
HOTSPOT_BUILD_CPU_DEFINE=$(echo $OPENJDK_BUILD_CPU | tr a-z A-Z)
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Continue setting up basic stuff. Most remaining code require fundamental tools.
|
|
|
|
# Save the current directory this script was started from
|
|
CURDIR="$PWD"
|
|
|
|
# We might need to rewrite ORIGINAL_PATH, if it includes "#", to quote them
|
|
# for make. We couldn't do this when we retrieved ORIGINAL_PATH, since SED
|
|
# was not available at that time.
|
|
REWRITTEN_PATH=`$ECHO "$ORIGINAL_PATH" | $SED -e 's/#/\\\\#/g'`
|
|
if test "x$REWRITTEN_PATH" != "x$ORIGINAL_PATH"; then
|
|
ORIGINAL_PATH="$REWRITTEN_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&5
|
|
$as_echo "$as_me: Rewriting ORIGINAL_PATH to $REWRITTEN_PATH" >&6;}
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
|
|
PATH_SEP=";"
|
|
|
|
SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
|
|
if test $SRC_ROOT_LENGTH -gt 100; then
|
|
as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
|
|
fi
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
|
|
$as_echo_n "checking cygwin release... " >&6; }
|
|
CYGWIN_VERSION=`$UNAME -r`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
|
|
$as_echo "$CYGWIN_VERSION" >&6; }
|
|
WINDOWS_ENV_VENDOR='cygwin'
|
|
WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
|
|
|
|
CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
|
|
if test "x$CYGWIN_VERSION_OLD" != x; then
|
|
{ $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
|
|
$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;}
|
|
as_fn_error $? "Cannot continue" "$LINENO" 5
|
|
fi
|
|
if test "x$CYGPATH" = x; then
|
|
as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
|
|
$as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
|
|
# The cmd output ends with Windows line endings (CR/LF)
|
|
cygwin_winpath_root=`cd / ; cmd /c cd | $TR -d '\r\n'`
|
|
# Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
|
|
CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
|
|
$as_echo "$CYGWIN_ROOT_PATH" >&6; }
|
|
WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
|
|
test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
|
|
fi
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
|
|
$as_echo_n "checking msys release... " >&6; }
|
|
MSYS_VERSION=`$UNAME -r`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
|
|
$as_echo "$MSYS_VERSION" >&6; }
|
|
|
|
WINDOWS_ENV_VENDOR='msys'
|
|
WINDOWS_ENV_VERSION="$MSYS_VERSION"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
|
|
$as_echo_n "checking msys root directory as unix-style path... " >&6; }
|
|
# The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
|
|
MSYS_ROOT_PATH=`cd / ; cmd /c cd | $GREP ".*"`
|
|
|
|
windows_path="$MSYS_ROOT_PATH"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
MSYS_ROOT_PATH="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
MSYS_ROOT_PATH="$unix_path"
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
|
|
$as_echo "$MSYS_ROOT_PATH" >&6; }
|
|
WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
|
|
else
|
|
as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
|
|
fi
|
|
|
|
# Test if windows or unix (cygwin/msys) find is first in path.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
|
|
$as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
|
|
FIND_BINARY_OUTPUT=`find --version 2>&1`
|
|
if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
|
|
$as_echo "unix style" >&6; }
|
|
elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
|
|
$as_echo "Windows" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
|
|
$as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
|
|
{ $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
|
|
$as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
|
|
as_fn_error $? "Cannot continue" "$LINENO" 5
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
|
|
$as_echo "unknown" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
|
|
$as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
|
|
fi
|
|
|
|
else
|
|
PATH_SEP=":"
|
|
fi
|
|
|
|
|
|
# We get the top-level directory from the supporting wrappers.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
|
|
$as_echo_n "checking for top-level directory... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
|
|
$as_echo "$TOPDIR" >&6; }
|
|
|
|
|
|
# Save the original version of TOPDIR for string comparisons
|
|
ORIGINAL_TOPDIR="$TOPDIR"
|
|
|
|
|
|
# We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$CURDIR" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$CURDIR"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
CURDIR="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$CURDIR"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
CURDIR="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$CURDIR"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
CURDIR="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
CURDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$TOPDIR" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$TOPDIR"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
TOPDIR="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$TOPDIR"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
TOPDIR="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$TOPDIR"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
TOPDIR="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# SRC_ROOT is a traditional alias for TOPDIR.
|
|
SRC_ROOT=$TOPDIR
|
|
|
|
# Calculate a canonical version of TOPDIR for string comparisons
|
|
CANONICAL_TOPDIR=$TOPDIR
|
|
|
|
if test "x$OPENJDK_BUILD_OS" != xwindows; then
|
|
# Follow a chain of symbolic links. Use readlink
|
|
# where it exists, else fall back to horribly
|
|
# complicated shell code.
|
|
if test "x$READLINK_TESTED" != yes; then
|
|
# On MacOSX there is a readlink tool with a different
|
|
# purpose than the GNU readlink tool. Check the found readlink.
|
|
ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
|
|
if test "x$ISGNU" = x; then
|
|
# A readlink that we do not know how to use.
|
|
# Are there other non-GNU readlinks out there?
|
|
READLINK_TESTED=yes
|
|
READLINK=
|
|
fi
|
|
fi
|
|
|
|
if test "x$READLINK" != x; then
|
|
CANONICAL_TOPDIR=`$READLINK -f $CANONICAL_TOPDIR`
|
|
else
|
|
# Save the current directory for restoring afterwards
|
|
STARTDIR=$PWD
|
|
COUNTER=0
|
|
sym_link_dir=`$DIRNAME $CANONICAL_TOPDIR`
|
|
sym_link_file=`$BASENAME $CANONICAL_TOPDIR`
|
|
cd $sym_link_dir
|
|
# Use -P flag to resolve symlinks in directories.
|
|
cd `$THEPWDCMD -P`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
# Resolve file symlinks
|
|
while test $COUNTER -lt 20; do
|
|
ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
|
|
if test "x$ISLINK" == x; then
|
|
# This is not a symbolic link! We are done!
|
|
break
|
|
fi
|
|
# Again resolve directory symlinks since the target of the just found
|
|
# link could be in a different directory
|
|
cd `$DIRNAME $ISLINK`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
sym_link_file=`$BASENAME $ISLINK`
|
|
let COUNTER=COUNTER+1
|
|
done
|
|
cd $STARTDIR
|
|
CANONICAL_TOPDIR=$sym_link_dir/$sym_link_file
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Locate the directory of this script.
|
|
AUTOCONF_DIR=$TOPDIR/common/autoconf
|
|
|
|
# Setup username (for use in adhoc version strings etc)
|
|
# Outer [ ] to quote m4.
|
|
USERNAME=`$ECHO "$USER" | $TR -d -c '[a-z][A-Z][0-9]'`
|
|
|
|
|
|
|
|
# Check if it's a pure open build or if custom sources are to be used.
|
|
|
|
# Check whether --enable-openjdk-only was given.
|
|
if test "${enable_openjdk_only+set}" = set; then :
|
|
enableval=$enable_openjdk_only;
|
|
else
|
|
enable_openjdk_only="no"
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if custom source is suppressed (openjdk-only)" >&5
|
|
$as_echo_n "checking if custom source is suppressed (openjdk-only)... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_openjdk_only" >&5
|
|
$as_echo "$enable_openjdk_only" >&6; }
|
|
if test "x$enable_openjdk_only" = "xyes"; then
|
|
SUPPRESS_CUSTOM_EXTENSIONS="true"
|
|
elif test "x$enable_openjdk_only" = "xno"; then
|
|
SUPPRESS_CUSTOM_EXTENSIONS="false"
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-openjdk-only: $enable_openjdk_only" "$LINENO" 5
|
|
fi
|
|
|
|
# custom-make-dir is deprecated. Please use your custom-hook.m4 to override
|
|
# the IncludeCustomExtension macro.
|
|
|
|
|
|
# Check whether --with-custom-make-dir was given.
|
|
if test "${with_custom_make_dir+set}" = set; then :
|
|
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
|
|
$as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# These are needed to be able to create a configuration name (and thus the output directory)
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
|
|
$as_echo_n "checking which variant of the JDK to build... " >&6; }
|
|
|
|
# Check whether --with-jdk-variant was given.
|
|
if test "${with_jdk_variant+set}" = set; then :
|
|
withval=$with_jdk_variant;
|
|
fi
|
|
|
|
|
|
if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
|
|
JDK_VARIANT="normal"
|
|
else
|
|
as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
|
|
$as_echo "$JDK_VARIANT" >&6; }
|
|
|
|
|
|
DEBUG_LEVEL="release"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
|
|
$as_echo_n "checking which debug level to use... " >&6; }
|
|
# Check whether --enable-debug was given.
|
|
if test "${enable_debug+set}" = set; then :
|
|
enableval=$enable_debug;
|
|
ENABLE_DEBUG="${enableval}"
|
|
DEBUG_LEVEL="fastdebug"
|
|
|
|
else
|
|
ENABLE_DEBUG="no"
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-debug-level was given.
|
|
if test "${with_debug_level+set}" = set; then :
|
|
withval=$with_debug_level;
|
|
DEBUG_LEVEL="${withval}"
|
|
if test "x$ENABLE_DEBUG" = xyes; then
|
|
as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
|
|
fi
|
|
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
|
|
$as_echo "$DEBUG_LEVEL" >&6; }
|
|
|
|
if test "x$DEBUG_LEVEL" != xrelease && \
|
|
test "x$DEBUG_LEVEL" != xoptimized && \
|
|
test "x$DEBUG_LEVEL" != xfastdebug && \
|
|
test "x$DEBUG_LEVEL" != xslowdebug; then
|
|
as_fn_error $? "Allowed debug levels are: release, fastdebug, slowdebug and optimized" "$LINENO" 5
|
|
fi
|
|
|
|
# Translate DEBUG_LEVEL to debug level used by Hotspot
|
|
HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
|
|
if test "x$DEBUG_LEVEL" = xrelease; then
|
|
HOTSPOT_DEBUG_LEVEL="product"
|
|
elif test "x$DEBUG_LEVEL" = xslowdebug; then
|
|
HOTSPOT_DEBUG_LEVEL="debug"
|
|
fi
|
|
|
|
if test "x$DEBUG_LEVEL" = xoptimized; then
|
|
# The debug level 'optimized' is a little special because it is currently only
|
|
# applicable to the HotSpot build where it means to build a completely
|
|
# optimized version of the VM without any debugging code (like for the
|
|
# 'release' debug level which is called 'product' in the HotSpot build) but
|
|
# with the exception that it can contain additional code which is otherwise
|
|
# protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
|
|
# test new and/or experimental features which are not intended for customer
|
|
# shipment. Because these new features need to be tested and benchmarked in
|
|
# real world scenarios, we want to build the containing JDK at the 'release'
|
|
# debug level.
|
|
DEBUG_LEVEL="release"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-jvm-variants was given.
|
|
if test "${with_jvm_variants+set}" = set; then :
|
|
withval=$with_jvm_variants;
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-cpu-port was given.
|
|
if test "${with_cpu_port+set}" = set; then :
|
|
withval=$with_cpu_port;
|
|
fi
|
|
|
|
|
|
if test "x$with_cpu_port" != x; then
|
|
if test "x$OPENJDK_TARGET_CPU" != xaarch64; then
|
|
as_fn_error $? "--with-cpu-port only available on aarch64" "$LINENO" 5
|
|
fi
|
|
if test "x$with_cpu_port" != xarm64 && \
|
|
test "x$with_cpu_port" != xaarch64; then
|
|
as_fn_error $? "--with-cpu-port must specify arm64 or aarch64" "$LINENO" 5
|
|
fi
|
|
HOTSPOT_TARGET_CPU_PORT="$with_cpu_port"
|
|
fi
|
|
|
|
|
|
if test "x$with_jvm_variants" = x; then
|
|
with_jvm_variants="server"
|
|
fi
|
|
JVM_VARIANTS_OPT="$with_jvm_variants"
|
|
|
|
# Has the user listed more than one variant?
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if [[ "$JVM_VARIANTS_OPT" =~ "," ]] ; then
|
|
BUILDING_MULTIPLE_JVM_VARIANTS=true
|
|
else
|
|
BUILDING_MULTIPLE_JVM_VARIANTS=false
|
|
fi
|
|
# Replace the commas with AND for use in the build directory name.
|
|
JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
|
|
$as_echo_n "checking which variants of the JVM to build... " >&6; }
|
|
# JVM_VARIANTS is a space-separated list.
|
|
# Also use minimal, not minimal1 (which is kept for backwards compatibility).
|
|
JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_VARIANTS" >&5
|
|
$as_echo "$JVM_VARIANTS" >&6; }
|
|
|
|
# Check that the selected variants are valid
|
|
|
|
# grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
|
|
# Notice that the original variant failes on SLES 10 and 11
|
|
NEEDLE=${VALID_JVM_VARIANTS// /$'\n'}
|
|
STACK=${JVM_VARIANTS// /$'\n'}
|
|
INVALID_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
|
|
if test "x$INVALID_VARIANTS" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Unknown variant(s) specified: $INVALID_VARIANTS" >&5
|
|
$as_echo "$as_me: Unknown variant(s) specified: $INVALID_VARIANTS" >&6;}
|
|
as_fn_error $? "The available JVM variants are: $VALID_JVM_VARIANTS" "$LINENO" 5
|
|
fi
|
|
|
|
# All "special" variants share the same output directory ("server")
|
|
VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
|
|
NEEDLE=${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}
|
|
STACK=${JVM_VARIANTS// /$'\n'}
|
|
INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
|
|
if test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
|
|
as_fn_error $? "You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS." "$LINENO" 5
|
|
fi
|
|
|
|
# The "main" variant is the one used by other libs to link against during the
|
|
# build.
|
|
if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xtrue"; then
|
|
MAIN_VARIANT_PRIO_ORDER="server client minimal"
|
|
for variant in $MAIN_VARIANT_PRIO_ORDER; do
|
|
if [[ " $JVM_VARIANTS " =~ " $variant " ]] ; then
|
|
JVM_VARIANT_MAIN="$variant"
|
|
break
|
|
fi
|
|
done
|
|
else
|
|
JVM_VARIANT_MAIN="$JVM_VARIANTS"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
if [[ " $JVM_VARIANTS " =~ " zero " ]] || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
# zero behaves as a platform and rewrites these values. This is really weird. :(
|
|
# We are guaranteed that we do not build any other variants when building zero.
|
|
HOTSPOT_TARGET_CPU=zero
|
|
HOTSPOT_TARGET_CPU_ARCH=zero
|
|
fi
|
|
|
|
|
|
# With basic setup done, call the custom early hook.
|
|
|
|
|
|
# Check if we have devkits, extra paths or sysroot set.
|
|
|
|
|
|
# Check whether --with-devkit was given.
|
|
if test "${with_devkit+set}" = set; then :
|
|
withval=$with_devkit;
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$with_devkit" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$with_devkit"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
with_devkit="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$with_devkit"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
with_devkit="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$with_devkit"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
with_devkit="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
with_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
DEVKIT_ROOT="$with_devkit"
|
|
# Check for a meta data info file in the root of the devkit
|
|
if test -f "$DEVKIT_ROOT/devkit.info"; then
|
|
. $DEVKIT_ROOT/devkit.info
|
|
# This potentially sets the following:
|
|
# A descriptive name of the devkit
|
|
|
|
if test "x$DEVKIT_NAME" = x; then
|
|
eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-extra-path
|
|
|
|
if test "x$DEVKIT_EXTRA_PATH" = x; then
|
|
eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-toolchain-path
|
|
|
|
if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
|
|
eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-sysroot
|
|
|
|
if test "x$DEVKIT_SYSROOT" = x; then
|
|
eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
|
|
# Identifies the Visual Studio version in the devkit
|
|
|
|
if test "x$DEVKIT_VS_VERSION" = x; then
|
|
eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# The Visual Studio include environment variable
|
|
|
|
if test "x$DEVKIT_VS_INCLUDE" = x; then
|
|
eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# The Visual Studio lib environment variable
|
|
|
|
if test "x$DEVKIT_VS_LIB" = x; then
|
|
eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-msvcr-dll
|
|
|
|
if test "x$DEVKIT_MSVCR_DLL" = x; then
|
|
eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-msvcp-dll
|
|
|
|
if test "x$DEVKIT_MSVCP_DLL" = x; then
|
|
eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
|
|
$as_echo_n "checking for devkit... " >&6; }
|
|
if test "x$DEVKIT_NAME" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
|
|
$as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
|
|
$as_echo "$DEVKIT_ROOT" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DEVKIT_EXTRA_PATH" != x; then
|
|
if test "x$EXTRA_PATH" = x; then
|
|
EXTRA_PATH="$DEVKIT_EXTRA_PATH"
|
|
else
|
|
EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Fallback default of just /bin if DEVKIT_PATH is not defined
|
|
if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
|
|
DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
|
|
fi
|
|
|
|
if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
|
|
if test "x$TOOLCHAIN_PATH" = x; then
|
|
TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
|
|
else
|
|
TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
|
|
fi
|
|
fi
|
|
|
|
|
|
# If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
|
|
# places for backwards compatiblity.
|
|
if test "x$DEVKIT_SYSROOT" != x; then
|
|
SYSROOT="$DEVKIT_SYSROOT"
|
|
elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
|
|
SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
|
|
elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
|
|
SYSROOT="$DEVKIT_ROOT/$host/sys-root"
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
# You can force the sysroot if the sysroot encoded into the compiler tools
|
|
# is not correct.
|
|
|
|
# Check whether --with-sys-root was given.
|
|
if test "${with_sys_root+set}" = set; then :
|
|
withval=$with_sys_root; SYSROOT=$with_sys_root
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-sysroot was given.
|
|
if test "${with_sysroot+set}" = set; then :
|
|
withval=$with_sysroot; SYSROOT=$with_sysroot
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-tools-dir was given.
|
|
if test "${with_tools_dir+set}" = set; then :
|
|
withval=$with_tools_dir;
|
|
if test "x$with_tools_dir" != x; then
|
|
if test "x$TOOLCHAIN_PATH" = x; then
|
|
TOOLCHAIN_PATH="$with_tools_dir"
|
|
else
|
|
TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
|
|
fi
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-toolchain-path was given.
|
|
if test "${with_toolchain_path+set}" = set; then :
|
|
withval=$with_toolchain_path;
|
|
if test "x$with_toolchain_path" != x; then
|
|
if test "x$TOOLCHAIN_PATH" = x; then
|
|
TOOLCHAIN_PATH="$with_toolchain_path"
|
|
else
|
|
TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
|
|
fi
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-extra-path was given.
|
|
if test "${with_extra_path+set}" = set; then :
|
|
withval=$with_extra_path;
|
|
if test "x$with_extra_path" != x; then
|
|
if test "x$EXTRA_PATH" = x; then
|
|
EXTRA_PATH="$with_extra_path"
|
|
else
|
|
EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
|
|
fi
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
|
|
# If a devkit has been supplied, find xcodebuild in the toolchain_path.
|
|
# If not, detect if Xcode is installed by running xcodebuild -version
|
|
# if no Xcode installed, xcodebuild exits with 1
|
|
# if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
|
|
if test "x$DEVKIT_ROOT" != x || /usr/bin/xcodebuild -version >/dev/null 2>&1; then
|
|
# We need to use xcodebuild in the toolchain dir provided by the user, this will
|
|
# fall back on the stub binary in /usr/bin/xcodebuild
|
|
# Extract the first word of "xcodebuild", so it can be a program name with args.
|
|
set dummy xcodebuild; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XCODEBUILD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XCODEBUILD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $TOOLCHAIN_PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
|
|
;;
|
|
esac
|
|
fi
|
|
XCODEBUILD=$ac_cv_path_XCODEBUILD
|
|
if test -n "$XCODEBUILD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
|
|
$as_echo "$XCODEBUILD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
else
|
|
# this should result in SYSROOT being empty, unless --with-sysroot is provided
|
|
# when only the command line tools are installed there are no SDKs, so headers
|
|
# are copied into the system frameworks
|
|
XCODEBUILD=
|
|
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
|
|
$as_echo_n "checking for sdk name... " >&6; }
|
|
|
|
# Check whether --with-sdk-name was given.
|
|
if test "${with_sdk_name+set}" = set; then :
|
|
withval=$with_sdk_name; SDKNAME=$with_sdk_name
|
|
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
|
|
$as_echo "$SDKNAME" >&6; }
|
|
|
|
# if toolchain path is specified then don't rely on system headers, they may not compile
|
|
HAVE_SYSTEM_FRAMEWORK_HEADERS=0
|
|
test -z "$TOOLCHAIN_PATH" && \
|
|
HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
|
|
|
|
if test -z "$SYSROOT"; then
|
|
if test -n "$XCODEBUILD"; then
|
|
# if we don't have system headers, use default SDK name (last resort)
|
|
if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
|
|
SDKNAME=${SDKNAME:-macosx}
|
|
fi
|
|
|
|
if test -n "$SDKNAME"; then
|
|
# Call xcodebuild to determine SYSROOT
|
|
SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | $GREP '^Path: ' | $SED 's/Path: //'`
|
|
fi
|
|
else
|
|
if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
|
|
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
|
|
fi
|
|
fi
|
|
else
|
|
# warn user if --with-sdk-name was also set
|
|
if test -n "$with_sdk_name"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
|
|
$as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
|
|
fi
|
|
fi
|
|
|
|
if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
|
|
# If no system framework headers, then SYSROOT must be set, or we won't build
|
|
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
|
|
fi
|
|
|
|
# Perform a basic sanity test
|
|
if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
|
|
if test -z "$SYSROOT"; then
|
|
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
|
|
else
|
|
as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# set SDKROOT too, Xcode tools will pick it up
|
|
SDKROOT="$SYSROOT"
|
|
|
|
fi
|
|
|
|
# Prepend the extra path to the global path
|
|
|
|
if test "x$EXTRA_PATH" != x; then
|
|
if test "x$PATH" = x; then
|
|
PATH="$EXTRA_PATH"
|
|
else
|
|
PATH="$EXTRA_PATH:$PATH"
|
|
fi
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
|
|
$as_echo_n "checking for sysroot... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
|
|
$as_echo "$SYSROOT" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
|
|
$as_echo_n "checking for toolchain path... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
|
|
$as_echo "$TOOLCHAIN_PATH" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
|
|
$as_echo_n "checking for extra path... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
|
|
$as_echo "$EXTRA_PATH" >&6; }
|
|
|
|
|
|
# To properly create a configuration name, we need to have the OpenJDK target
|
|
# and options (variants and debug level) parsed.
|
|
|
|
|
|
|
|
# Check whether --with-conf-name was given.
|
|
if test "${with_conf_name+set}" = set; then :
|
|
withval=$with_conf_name; CONF_NAME=${with_conf_name}
|
|
fi
|
|
|
|
|
|
# Test from where we are running configure, in or outside of src root.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
|
|
$as_echo_n "checking where to store configuration... " >&6; }
|
|
if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
|
|
|| test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
|
|
|| test "x$CURDIR" = "x$SRC_ROOT/make" ; then
|
|
# We are running configure from the src root.
|
|
# Create a default ./build/target-variant-debuglevel output root.
|
|
if test "x${CONF_NAME}" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
|
|
$as_echo "in default location" >&6; }
|
|
CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
|
|
$as_echo "in build directory with custom name" >&6; }
|
|
fi
|
|
OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
|
|
$MKDIR -p "$OUTPUT_ROOT"
|
|
if test ! -d "$OUTPUT_ROOT"; then
|
|
as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
|
|
fi
|
|
else
|
|
# We are running configure from outside of the src dir.
|
|
# Then use the current directory as output dir!
|
|
# If configuration is situated in normal build directory, just use the build
|
|
# directory name as configuration name, otherwise use the complete path.
|
|
if test "x${CONF_NAME}" = x; then
|
|
CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
|
|
fi
|
|
OUTPUT_ROOT="$CURDIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
|
|
$as_echo "in current directory" >&6; }
|
|
|
|
# WARNING: This might be a bad thing to do. You need to be sure you want to
|
|
# have a configuration in this directory. Do some sanity checks!
|
|
|
|
if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
|
|
# If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
|
|
# other files
|
|
files_present=`$LS $OUTPUT_ROOT`
|
|
# Configure has already touched config.log and confdefs.h in the current dir when this check
|
|
# is performed.
|
|
filtered_files=`$ECHO "$files_present" \
|
|
| $SED -e 's/config.log//g' \
|
|
-e 's/configure.log//g' \
|
|
-e 's/confdefs.h//g' \
|
|
-e 's/ //g' \
|
|
| $TR -d '\n'`
|
|
if test "x$filtered_files" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
|
|
$as_echo "$as_me: Current directory is $CURDIR." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
|
|
$as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
|
|
$as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
|
|
$as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
|
|
$as_echo "$as_me: seriously mess up just about everything." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
|
|
$as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
|
|
$as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
|
|
as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
|
|
$as_echo_n "checking what configuration name to use... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
|
|
$as_echo "$CONF_NAME" >&6; }
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$OUTPUT_ROOT" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$OUTPUT_ROOT"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
OUTPUT_ROOT="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$OUTPUT_ROOT"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
OUTPUT_ROOT="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$OUTPUT_ROOT"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
OUTPUT_ROOT="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
CONFIGURESUPPORT_OUTPUTDIR="$OUTPUT_ROOT/configure-support"
|
|
$MKDIR -p "$CONFIGURESUPPORT_OUTPUTDIR"
|
|
|
|
SPEC="$OUTPUT_ROOT/spec.gmk"
|
|
|
|
|
|
|
|
|
|
|
|
# The spec.gmk file contains all variables for the make system.
|
|
ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
|
|
|
|
# The bootcycle-spec.gmk file contains support for boot cycle builds.
|
|
ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
|
|
|
|
# The buildjdk-spec.gmk file contains support for building a buildjdk when cross compiling.
|
|
ac_config_files="$ac_config_files $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in"
|
|
|
|
# The compare.sh is used to compare the build output to other builds.
|
|
ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
|
|
|
|
# The generated Makefile knows where the spec.gmk is and where the source is.
|
|
# You can run make from the OUTPUT_ROOT, or from the top-level Makefile
|
|
# which will look for generated configurations
|
|
ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
|
|
|
|
|
|
|
|
# Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
|
|
|
|
for ac_prog in apt-get yum brew port pkgutil pkgadd
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_PKGHANDLER+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$PKGHANDLER"; then
|
|
ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_PKGHANDLER="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
PKGHANDLER=$ac_cv_prog_PKGHANDLER
|
|
if test -n "$PKGHANDLER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
|
|
$as_echo "$PKGHANDLER" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PKGHANDLER" && break
|
|
done
|
|
|
|
|
|
|
|
# Setup tools that requires more complex handling, or that is not needed by the configure script.
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${MAKE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
|
|
# Try our hardest to locate a correct version of GNU make
|
|
for ac_prog in gmake
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_GMAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_GMAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
|
|
if test -n "$CHECK_GMAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
|
|
$as_echo "$CHECK_GMAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_GMAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_GMAKE""
|
|
DESCRIPTION="gmake in PATH"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
for ac_prog in make
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_MAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_MAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_MAKE=$ac_cv_path_CHECK_MAKE
|
|
if test -n "$CHECK_MAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
|
|
$as_echo "$CHECK_MAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_MAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_MAKE""
|
|
DESCRIPTION="make in PATH"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
if test "x$TOOLCHAIN_PATH" != x; then
|
|
# We have a toolchain path, check that as well before giving up.
|
|
OLD_PATH=$PATH
|
|
PATH=$TOOLCHAIN_PATH:$PATH
|
|
for ac_prog in gmake
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_TOOLSDIR_GMAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
|
|
if test -n "$CHECK_TOOLSDIR_GMAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
|
|
$as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_TOOLSDIR_GMAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
|
|
DESCRIPTION="gmake in tools-dir"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
for ac_prog in make
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_TOOLSDIR_MAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
|
|
if test -n "$CHECK_TOOLSDIR_MAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
|
|
$as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_TOOLSDIR_MAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
|
|
DESCRIPTION="make in tools-dir"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
PATH=$OLD_PATH
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
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
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !MAKE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MAKE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xMAKE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of MAKE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
|
|
# Try our hardest to locate a correct version of GNU make
|
|
for ac_prog in gmake
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_GMAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_GMAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
|
|
if test -n "$CHECK_GMAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
|
|
$as_echo "$CHECK_GMAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_GMAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_GMAKE""
|
|
DESCRIPTION="gmake in PATH"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
for ac_prog in make
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_MAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_MAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_MAKE=$ac_cv_path_CHECK_MAKE
|
|
if test -n "$CHECK_MAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
|
|
$as_echo "$CHECK_MAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_MAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_MAKE""
|
|
DESCRIPTION="make in PATH"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
if test "x$TOOLCHAIN_PATH" != x; then
|
|
# We have a toolchain path, check that as well before giving up.
|
|
OLD_PATH=$PATH
|
|
PATH=$TOOLCHAIN_PATH:$PATH
|
|
for ac_prog in gmake
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_TOOLSDIR_GMAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
|
|
if test -n "$CHECK_TOOLSDIR_GMAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
|
|
$as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_TOOLSDIR_GMAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
|
|
DESCRIPTION="gmake in tools-dir"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
for ac_prog in make
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CHECK_TOOLSDIR_MAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
|
|
if test -n "$CHECK_TOOLSDIR_MAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
|
|
$as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CHECK_TOOLSDIR_MAKE" && break
|
|
done
|
|
|
|
|
|
MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
|
|
DESCRIPTION="make in tools-dir"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
PATH=$OLD_PATH
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
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
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool MAKE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool MAKE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
|
|
$as_echo_n "checking for MAKE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$MAKE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MAKE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool MAKE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_MAKE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $MAKE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
MAKE=$ac_cv_path_MAKE
|
|
if test -n "$MAKE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
|
|
$as_echo "$MAKE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$MAKE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MAKE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool MAKE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for MAKE" >&5
|
|
$as_echo_n "checking for MAKE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool MAKE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# If MAKE was set by user, verify the version
|
|
|
|
MAKE_CANDIDATE=""$MAKE""
|
|
DESCRIPTION="user supplied MAKE=$MAKE"
|
|
|
|
# On Cygwin, we require a newer version of make than on other platforms
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_VERSION_EXPR="-e 4\."
|
|
MAKE_REQUIRED_VERSION="4.0"
|
|
else
|
|
MAKE_VERSION_EXPR="-e 3\.8[12] -e 4\."
|
|
MAKE_REQUIRED_VERSION="3.81"
|
|
fi
|
|
|
|
if test "x$MAKE_CANDIDATE" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
|
|
$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
|
|
MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
|
|
IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
|
|
if test "x$IS_GNU_MAKE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
|
|
$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
|
|
else
|
|
IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP $MAKE_VERSION_EXPR`
|
|
if test "x$IS_MODERN_MAKE" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
MAKE_EXPECTED_ENV='cygwin'
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
MAKE_EXPECTED_ENV='msys'
|
|
else
|
|
as_fn_error $? "Unknown Windows environment" "$LINENO" 5
|
|
fi
|
|
MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
|
|
IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
|
|
else
|
|
# Not relevant for non-Windows
|
|
IS_MAKE_CORRECT_ENV=true
|
|
fi
|
|
if test "x$IS_MAKE_CORRECT_ENV" = x; then
|
|
{ $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
|
|
$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;}
|
|
else
|
|
FOUND_MAKE=$MAKE_CANDIDATE
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FOUND_MAKE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$FOUND_MAKE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
FOUND_MAKE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_MAKE" = x; then
|
|
as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make $MAKE_REQUIRED_VERSION or newer." "$LINENO" 5
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
MAKE=$FOUND_MAKE
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
|
|
$as_echo "$as_me: Using GNU make at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
|
|
|
|
|
|
# Check if make supports the output sync option and if so, setup using it.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
|
|
$as_echo_n "checking if make --output-sync is supported... " >&6; }
|
|
if $MAKE --version -O > /dev/null 2>&1; then
|
|
OUTPUT_SYNC_SUPPORTED=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
|
|
$as_echo_n "checking for output-sync value... " >&6; }
|
|
|
|
# Check whether --with-output-sync was given.
|
|
if test "${with_output_sync+set}" = set; then :
|
|
withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
|
|
fi
|
|
|
|
if test "x$OUTPUT_SYNC" = "x"; then
|
|
OUTPUT_SYNC=none
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
|
|
$as_echo "$OUTPUT_SYNC" >&6; }
|
|
if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
|
|
as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
|
|
fi
|
|
else
|
|
OUTPUT_SYNC_SUPPORTED=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Test if find supports -delete
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
|
|
$as_echo_n "checking if find supports -delete... " >&6; }
|
|
FIND_DELETE="-delete"
|
|
|
|
DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
|
|
|
|
echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
|
|
|
|
TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
|
|
if test -f $DELETEDIR/TestIfFindSupportsDelete; then
|
|
# No, it does not.
|
|
$RM $DELETEDIR/TestIfFindSupportsDelete
|
|
if test "x$OPENJDK_TARGET_OS" = "xaix"; then
|
|
# AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
|
|
FIND_DELETE="-print | $XARGS $RM"
|
|
else
|
|
FIND_DELETE="-exec $RM \{\} \+"
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
$RMDIR $DELETEDIR
|
|
|
|
|
|
|
|
# Test which kind of tar was found
|
|
if test "x$($TAR --version | $GREP "GNU tar")" != "x"; then
|
|
TAR_TYPE="gnu"
|
|
elif test "x$($TAR --version | $GREP "bsdtar")" != "x"; then
|
|
TAR_TYPE="bsd"
|
|
elif test "x$($TAR -v | $GREP "bsdtar")" != "x"; then
|
|
TAR_TYPE="bsd"
|
|
elif test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
|
|
TAR_TYPE="solaris"
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of tar was found" >&5
|
|
$as_echo_n "checking what type of tar was found... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR_TYPE" >&5
|
|
$as_echo "$TAR_TYPE" >&6; }
|
|
|
|
TAR_CREATE_FILE_PARAM=""
|
|
|
|
if test "x$TAR_TYPE" = "xgnu"; then
|
|
TAR_INCLUDE_PARAM="T"
|
|
TAR_SUPPORTS_TRANSFORM="true"
|
|
if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
|
|
# When using gnu tar for Solaris targets, need to use compatibility mode
|
|
TAR_CREATE_EXTRA_PARAM="--format=ustar"
|
|
fi
|
|
else
|
|
TAR_INCLUDE_PARAM="I"
|
|
TAR_SUPPORTS_TRANSFORM="false"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Test that grep supports -Fx with a list of pattern which includes null pattern.
|
|
# This is a problem for the grep resident on AIX.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that grep ($GREP) -Fx handles empty lines in the pattern list correctly" >&5
|
|
$as_echo_n "checking that grep ($GREP) -Fx handles empty lines in the pattern list correctly... " >&6; }
|
|
# Multiple subsequent spaces..
|
|
STACK_SPACES='aaa bbb ccc'
|
|
# ..converted to subsequent newlines, causes STACK_LIST to be a list with some empty
|
|
# patterns in it.
|
|
STACK_LIST=${STACK_SPACES// /$'\n'}
|
|
NEEDLE_SPACES='ccc bbb aaa'
|
|
NEEDLE_LIST=${NEEDLE_SPACES// /$'\n'}
|
|
RESULT="$($GREP -Fvx "$STACK_LIST" <<< "$NEEDLE_LIST")"
|
|
if test "x$RESULT" == "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = "xaix"; then
|
|
ADDINFO="Please make sure you use GNU grep, usually found at /opt/freeware/bin."
|
|
fi
|
|
as_fn_error $? "grep does not handle -Fx correctly. ${ADDINFO}" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
# These tools might not be installed by default,
|
|
# need hint on how to install them.
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${UNZIP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in unzip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNZIP=$ac_cv_path_UNZIP
|
|
if test -n "$UNZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
|
|
$as_echo "$UNZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$UNZIP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !UNZIP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xUNZIP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in unzip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNZIP=$ac_cv_path_UNZIP
|
|
if test -n "$UNZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
|
|
$as_echo "$UNZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$UNZIP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$UNZIP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool UNZIP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool UNZIP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
|
|
$as_echo_n "checking for UNZIP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$UNZIP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_UNZIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $UNZIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
UNZIP=$ac_cv_path_UNZIP
|
|
if test -n "$UNZIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
|
|
$as_echo "$UNZIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$UNZIP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
|
|
$as_echo_n "checking for UNZIP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$UNZIP" = x; then
|
|
as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
# Since zip uses "ZIP" as a environment variable for passing options, we need
|
|
# to name our variable differently, hence ZIPEXE.
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${ZIPEXE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in zip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ZIPEXE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ZIPEXE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ZIPEXE="$ZIPEXE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ZIPEXE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ZIPEXE=$ac_cv_path_ZIPEXE
|
|
if test -n "$ZIPEXE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIPEXE" >&5
|
|
$as_echo "$ZIPEXE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ZIPEXE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !ZIPEXE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIPEXE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xZIPEXE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIPEXE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of ZIPEXE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in zip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ZIPEXE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ZIPEXE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ZIPEXE="$ZIPEXE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ZIPEXE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ZIPEXE=$ac_cv_path_ZIPEXE
|
|
if test -n "$ZIPEXE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIPEXE" >&5
|
|
$as_echo "$ZIPEXE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ZIPEXE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$ZIPEXE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ZIPEXE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool ZIPEXE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIPEXE" >&5
|
|
$as_echo_n "checking for ZIPEXE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$ZIPEXE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIPEXE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool ZIPEXE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ZIPEXE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ZIPEXE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ZIPEXE="$ZIPEXE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ZIPEXE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ZIPEXE=$ac_cv_path_ZIPEXE
|
|
if test -n "$ZIPEXE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIPEXE" >&5
|
|
$as_echo "$ZIPEXE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$ZIPEXE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIPEXE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool ZIPEXE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIPEXE" >&5
|
|
$as_echo_n "checking for ZIPEXE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool ZIPEXE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$ZIPEXE" = x; then
|
|
as_fn_error $? "Could not find required tool for ZIPEXE" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Non-required basic tools
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${LDD+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in ldd
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LDD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LDD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LDD=$ac_cv_path_LDD
|
|
if test -n "$LDD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
|
|
$as_echo "$LDD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LDD" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !LDD! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xLDD" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in ldd
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LDD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LDD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LDD=$ac_cv_path_LDD
|
|
if test -n "$LDD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
|
|
$as_echo "$LDD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LDD" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$LDD" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LDD= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool LDD= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
|
|
$as_echo_n "checking for LDD... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$LDD"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LDD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LDD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LDD=$ac_cv_path_LDD
|
|
if test -n "$LDD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
|
|
$as_echo "$LDD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$LDD" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
|
|
$as_echo_n "checking for LDD... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$LDD" = "x"; then
|
|
# List shared lib dependencies is used for
|
|
# debug output and checking for forbidden dependencies.
|
|
# We can build without it.
|
|
LDD="true"
|
|
fi
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${OTOOL+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in otool
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_OTOOL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $OTOOL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
OTOOL=$ac_cv_path_OTOOL
|
|
if test -n "$OTOOL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
|
|
$as_echo "$OTOOL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$OTOOL" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !OTOOL! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xOTOOL" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in otool
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_OTOOL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $OTOOL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
OTOOL=$ac_cv_path_OTOOL
|
|
if test -n "$OTOOL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
|
|
$as_echo "$OTOOL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$OTOOL" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$OTOOL" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OTOOL= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool OTOOL= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
|
|
$as_echo_n "checking for OTOOL... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$OTOOL"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_OTOOL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $OTOOL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
OTOOL=$ac_cv_path_OTOOL
|
|
if test -n "$OTOOL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
|
|
$as_echo "$OTOOL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$OTOOL" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
|
|
$as_echo_n "checking for OTOOL... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$OTOOL" = "x"; then
|
|
OTOOL="true"
|
|
fi
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${READELF+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in greadelf readelf
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_READELF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $READELF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
READELF=$ac_cv_path_READELF
|
|
if test -n "$READELF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
|
|
$as_echo "$READELF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$READELF" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !READELF! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xREADELF" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in greadelf readelf
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_READELF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $READELF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
READELF=$ac_cv_path_READELF
|
|
if test -n "$READELF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
|
|
$as_echo "$READELF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$READELF" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$READELF" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool READELF= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool READELF= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
|
|
$as_echo_n "checking for READELF... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$READELF"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_READELF+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $READELF in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
READELF=$ac_cv_path_READELF
|
|
if test -n "$READELF"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
|
|
$as_echo "$READELF" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$READELF" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
|
|
$as_echo_n "checking for READELF... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DOT+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in dot
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DOT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DOT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DOT=$ac_cv_path_DOT
|
|
if test -n "$DOT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
|
|
$as_echo "$DOT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DOT" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DOT! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DOT!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDOT" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DOT from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DOT from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in dot
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DOT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DOT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DOT=$ac_cv_path_DOT
|
|
if test -n "$DOT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
|
|
$as_echo "$DOT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DOT" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DOT" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DOT= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DOT= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DOT" >&5
|
|
$as_echo_n "checking for DOT... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DOT"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DOT=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DOT=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DOT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DOT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DOT=$ac_cv_path_DOT
|
|
if test -n "$DOT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
|
|
$as_echo "$DOT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DOT" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DOT=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DOT=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DOT" >&5
|
|
$as_echo_n "checking for DOT... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DOT=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${HG+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in hg
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_HG+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $HG in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_HG="$HG" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
HG=$ac_cv_path_HG
|
|
if test -n "$HG"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
|
|
$as_echo "$HG" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$HG" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !HG! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xHG" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in hg
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_HG+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $HG in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_HG="$HG" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
HG=$ac_cv_path_HG
|
|
if test -n "$HG"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
|
|
$as_echo "$HG" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$HG" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$HG" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool HG= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool HG= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
|
|
$as_echo_n "checking for HG... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$HG"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_HG+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $HG in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_HG="$HG" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
HG=$ac_cv_path_HG
|
|
if test -n "$HG"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
|
|
$as_echo "$HG" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$HG" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
|
|
$as_echo_n "checking for HG... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${STAT+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in stat
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STAT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STAT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STAT=$ac_cv_path_STAT
|
|
if test -n "$STAT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
|
|
$as_echo "$STAT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$STAT" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !STAT! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSTAT" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in stat
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STAT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STAT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STAT=$ac_cv_path_STAT
|
|
if test -n "$STAT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
|
|
$as_echo "$STAT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$STAT" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$STAT" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STAT= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool STAT= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
|
|
$as_echo_n "checking for STAT... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$STAT"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STAT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STAT in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STAT=$ac_cv_path_STAT
|
|
if test -n "$STAT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
|
|
$as_echo "$STAT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$STAT" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
|
|
$as_echo_n "checking for STAT... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${TIME+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in time
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TIME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TIME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TIME=$ac_cv_path_TIME
|
|
if test -n "$TIME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
|
|
$as_echo "$TIME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TIME" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !TIME! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xTIME" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in time
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TIME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TIME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TIME=$ac_cv_path_TIME
|
|
if test -n "$TIME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
|
|
$as_echo "$TIME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$TIME" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$TIME" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool TIME= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool TIME= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
|
|
$as_echo_n "checking for TIME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$TIME"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TIME+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TIME in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TIME=$ac_cv_path_TIME
|
|
if test -n "$TIME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
|
|
$as_echo "$TIME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$TIME" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
|
|
$as_echo_n "checking for TIME... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${FLOCK+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in flock
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FLOCK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FLOCK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FLOCK="$FLOCK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FLOCK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FLOCK=$ac_cv_path_FLOCK
|
|
if test -n "$FLOCK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLOCK" >&5
|
|
$as_echo "$FLOCK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$FLOCK" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !FLOCK! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FLOCK!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xFLOCK" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FLOCK from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of FLOCK from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in flock
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FLOCK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FLOCK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FLOCK="$FLOCK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FLOCK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FLOCK=$ac_cv_path_FLOCK
|
|
if test -n "$FLOCK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLOCK" >&5
|
|
$as_echo "$FLOCK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$FLOCK" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$FLOCK" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool FLOCK= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool FLOCK= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FLOCK" >&5
|
|
$as_echo_n "checking for FLOCK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$FLOCK"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FLOCK=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool FLOCK=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_FLOCK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $FLOCK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_FLOCK="$FLOCK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_FLOCK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
FLOCK=$ac_cv_path_FLOCK
|
|
if test -n "$FLOCK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLOCK" >&5
|
|
$as_echo "$FLOCK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$FLOCK" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FLOCK=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool FLOCK=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FLOCK" >&5
|
|
$as_echo_n "checking for FLOCK... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool FLOCK=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# Dtrace is usually found in /usr/sbin on Solaris, but that directory may not
|
|
# be in the user path.
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DTRACE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in dtrace
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DTRACE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DTRACE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
as_dummy="$PATH:/usr/sbin"
|
|
for as_dir in $as_dummy
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DTRACE=$ac_cv_path_DTRACE
|
|
if test -n "$DTRACE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
|
|
$as_echo "$DTRACE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DTRACE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DTRACE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DTRACE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDTRACE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DTRACE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in dtrace
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DTRACE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DTRACE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
as_dummy="$PATH:/usr/sbin"
|
|
for as_dir in $as_dummy
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DTRACE=$ac_cv_path_DTRACE
|
|
if test -n "$DTRACE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
|
|
$as_echo "$DTRACE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DTRACE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DTRACE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DTRACE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DTRACE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
|
|
$as_echo_n "checking for DTRACE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DTRACE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DTRACE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DTRACE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DTRACE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DTRACE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DTRACE="$DTRACE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DTRACE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DTRACE=$ac_cv_path_DTRACE
|
|
if test -n "$DTRACE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
|
|
$as_echo "$DTRACE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DTRACE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DTRACE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DTRACE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DTRACE" >&5
|
|
$as_echo_n "checking for DTRACE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DTRACE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${PATCH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in gpatch patch
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PATCH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PATCH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PATCH=$ac_cv_path_PATCH
|
|
if test -n "$PATCH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
|
|
$as_echo "$PATCH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PATCH" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !PATCH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PATCH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xPATCH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of PATCH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in gpatch patch
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PATCH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PATCH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PATCH=$ac_cv_path_PATCH
|
|
if test -n "$PATCH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
|
|
$as_echo "$PATCH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$PATCH" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$PATCH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool PATCH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool PATCH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
|
|
$as_echo_n "checking for PATCH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$PATCH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PATCH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool PATCH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PATCH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PATCH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PATCH="$PATCH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PATCH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PATCH=$ac_cv_path_PATCH
|
|
if test -n "$PATCH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5
|
|
$as_echo "$PATCH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$PATCH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PATCH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool PATCH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PATCH" >&5
|
|
$as_echo_n "checking for PATCH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool PATCH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# Check if it's GNU time
|
|
IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
|
|
if test "x$IS_GNU_TIME" != x; then
|
|
IS_GNU_TIME=yes
|
|
else
|
|
IS_GNU_TIME=no
|
|
fi
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${DSYMUTIL+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in dsymutil
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DSYMUTIL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DSYMUTIL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DSYMUTIL=$ac_cv_path_DSYMUTIL
|
|
if test -n "$DSYMUTIL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
|
|
$as_echo "$DSYMUTIL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DSYMUTIL" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !DSYMUTIL! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xDSYMUTIL" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in dsymutil
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DSYMUTIL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DSYMUTIL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DSYMUTIL=$ac_cv_path_DSYMUTIL
|
|
if test -n "$DSYMUTIL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
|
|
$as_echo "$DSYMUTIL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$DSYMUTIL" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$DSYMUTIL" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool DSYMUTIL= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool DSYMUTIL= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
|
|
$as_echo_n "checking for DSYMUTIL... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$DSYMUTIL"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_DSYMUTIL+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $DSYMUTIL in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
DSYMUTIL=$ac_cv_path_DSYMUTIL
|
|
if test -n "$DSYMUTIL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
|
|
$as_echo "$DSYMUTIL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$DSYMUTIL" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
|
|
$as_echo_n "checking for DSYMUTIL... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$DSYMUTIL" = x; then
|
|
as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${XATTR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in xattr
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XATTR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XATTR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
XATTR=$ac_cv_path_XATTR
|
|
if test -n "$XATTR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
|
|
$as_echo "$XATTR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$XATTR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !XATTR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xXATTR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in xattr
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XATTR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XATTR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
XATTR=$ac_cv_path_XATTR
|
|
if test -n "$XATTR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
|
|
$as_echo "$XATTR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$XATTR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$XATTR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool XATTR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool XATTR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
|
|
$as_echo_n "checking for XATTR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$XATTR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_XATTR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $XATTR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
XATTR=$ac_cv_path_XATTR
|
|
if test -n "$XATTR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
|
|
$as_echo "$XATTR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$XATTR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
|
|
$as_echo_n "checking for XATTR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$XATTR" = x; then
|
|
as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CODESIGN+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in codesign
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CODESIGN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CODESIGN in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CODESIGN=$ac_cv_path_CODESIGN
|
|
if test -n "$CODESIGN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
|
|
$as_echo "$CODESIGN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CODESIGN" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CODESIGN! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCODESIGN" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in codesign
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CODESIGN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CODESIGN in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CODESIGN=$ac_cv_path_CODESIGN
|
|
if test -n "$CODESIGN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
|
|
$as_echo "$CODESIGN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CODESIGN" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CODESIGN" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CODESIGN= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CODESIGN= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
|
|
$as_echo_n "checking for CODESIGN... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CODESIGN"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CODESIGN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CODESIGN in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CODESIGN=$ac_cv_path_CODESIGN
|
|
if test -n "$CODESIGN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
|
|
$as_echo "$CODESIGN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CODESIGN" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
|
|
$as_echo_n "checking for CODESIGN... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$CODESIGN" != "x"; then
|
|
# Verify that the openjdk_codesign certificate is present
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
|
|
$as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
|
|
$RM codesign-testfile
|
|
$TOUCH codesign-testfile
|
|
$CODESIGN -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
|
|
$RM codesign-testfile
|
|
if test "x$CODESIGN" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${SETFILE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in SetFile
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SETFILE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SETFILE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SETFILE=$ac_cv_path_SETFILE
|
|
if test -n "$SETFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
|
|
$as_echo "$SETFILE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$SETFILE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !SETFILE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSETFILE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in SetFile
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SETFILE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SETFILE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SETFILE=$ac_cv_path_SETFILE
|
|
if test -n "$SETFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
|
|
$as_echo "$SETFILE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$SETFILE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$SETFILE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool SETFILE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool SETFILE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
|
|
$as_echo_n "checking for SETFILE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$SETFILE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_SETFILE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $SETFILE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
SETFILE=$ac_cv_path_SETFILE
|
|
if test -n "$SETFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
|
|
$as_echo "$SETFILE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$SETFILE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
|
|
$as_echo_n "checking for SETFILE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$SETFILE" = x; then
|
|
as_fn_error $? "Could not find required tool for SETFILE" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
# Check bash version
|
|
# Extra [ ] to stop m4 mangling
|
|
BASH_VER=`$BASH --version | $SED -n -e 's/^.*bash.*ersion *\([0-9.]*\).*$/\1/ p'`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking bash version" >&5
|
|
$as_echo_n "checking bash version... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH_VER" >&5
|
|
$as_echo "$BASH_VER" >&6; }
|
|
|
|
BASH_MAJOR=`$ECHO $BASH_VER | $CUT -d . -f 1`
|
|
BASH_MINOR=`$ECHO $BASH_VER | $CUT -d . -f 2`
|
|
if test $BASH_MAJOR -lt 3 || (test $BASH_MAJOR -eq 3 && test $BASH_MINOR -lt 2); then
|
|
as_fn_error $? "bash version 3.2 or better is required" "$LINENO" 5
|
|
fi
|
|
|
|
# Test if bash supports pipefail.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
|
|
$as_echo_n "checking if bash supports pipefail... " >&6; }
|
|
if ${BASH} -c 'set -o pipefail'; then
|
|
BASH_ARGS="$BASH_ARGS -o pipefail"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
|
|
$as_echo_n "checking if bash supports errexit (-e)... " >&6; }
|
|
if ${BASH} -e -c 'true'; then
|
|
BASH_ARGS="$BASH_ARGS -e"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check if pkg-config is available.
|
|
|
|
|
|
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
|
|
if test -n "$ac_tool_prefix"; then
|
|
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
|
|
set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_PKG_CONFIG+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $PKG_CONFIG in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
PKG_CONFIG=$ac_cv_path_PKG_CONFIG
|
|
if test -n "$PKG_CONFIG"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
|
|
$as_echo "$PKG_CONFIG" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
fi
|
|
if test -z "$ac_cv_path_PKG_CONFIG"; then
|
|
ac_pt_PKG_CONFIG=$PKG_CONFIG
|
|
# Extract the first word of "pkg-config", so it can be a program name with args.
|
|
set dummy pkg-config; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ac_pt_PKG_CONFIG in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
|
|
if test -n "$ac_pt_PKG_CONFIG"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
|
|
$as_echo "$ac_pt_PKG_CONFIG" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
if test "x$ac_pt_PKG_CONFIG" = x; then
|
|
PKG_CONFIG=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
PKG_CONFIG=$ac_pt_PKG_CONFIG
|
|
fi
|
|
else
|
|
PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
|
|
fi
|
|
|
|
fi
|
|
if test -n "$PKG_CONFIG"; then
|
|
_pkg_min_version=0.9.0
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
|
|
$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
|
|
if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
PKG_CONFIG=""
|
|
fi
|
|
|
|
fi
|
|
|
|
# After basic tools have been setup, we can check build os specific details.
|
|
|
|
###############################################################################
|
|
|
|
# Note that this is the build platform OS version!
|
|
|
|
OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
|
|
OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
|
|
OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
|
|
OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
|
|
|
|
|
|
|
|
|
|
|
|
# Misc basic settings
|
|
|
|
|
|
# Check whether --with-default-make-target was given.
|
|
if test "${with_default_make_target+set}" = set; then :
|
|
withval=$with_default_make_target;
|
|
fi
|
|
|
|
if test "x$with_default_make_target" = "x" \
|
|
|| test "x$with_default_make_target" = "xyes"; then
|
|
DEFAULT_MAKE_TARGET="exploded-image"
|
|
elif test "x$with_default_make_target" = "xno"; then
|
|
as_fn_error $? "--without-default-make-target is not a valid option" "$LINENO" 5
|
|
else
|
|
DEFAULT_MAKE_TARGET="$with_default_make_target"
|
|
fi
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Determine OpenJDK variants, options and version numbers.
|
|
#
|
|
###############################################################################
|
|
|
|
# We need build & target for this.
|
|
|
|
# Should we build a JDK without a graphical UI?
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking headless only" >&5
|
|
$as_echo_n "checking headless only... " >&6; }
|
|
# Check whether --enable-headless-only was given.
|
|
if test "${enable_headless_only+set}" = set; then :
|
|
enableval=$enable_headless_only;
|
|
fi
|
|
|
|
|
|
if test "x$enable_headless_only" = "xyes"; then
|
|
ENABLE_HEADLESS_ONLY="true"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
elif test "x$enable_headless_only" = "xno"; then
|
|
ENABLE_HEADLESS_ONLY="false"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
elif test "x$enable_headless_only" = "x"; then
|
|
ENABLE_HEADLESS_ONLY="false"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
else
|
|
as_fn_error $? "--enable-headless-only can only take yes or no" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Should we build the complete docs, or just a lightweight version?
|
|
# Check whether --enable-full-docs was given.
|
|
if test "${enable_full_docs+set}" = set; then :
|
|
enableval=$enable_full_docs;
|
|
fi
|
|
|
|
|
|
# Verify dependencies
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for graphviz dot" >&5
|
|
$as_echo_n "checking for graphviz dot... " >&6; }
|
|
if test "x$DOT" != "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, cannot generate full docs" >&5
|
|
$as_echo "no, cannot generate full docs" >&6; }
|
|
FULL_DOCS_DEP_MISSING=true
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pandoc" >&5
|
|
$as_echo_n "checking for pandoc... " >&6; }
|
|
if test "x$PANDOC" != "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, cannot generate full docs" >&5
|
|
$as_echo "no, cannot generate full docs" >&6; }
|
|
FULL_DOCS_DEP_MISSING=true
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking full docs" >&5
|
|
$as_echo_n "checking full docs... " >&6; }
|
|
if test "x$enable_full_docs" = xyes; then
|
|
if test "x$FULL_DOCS_DEP_MISSING" = "xtrue"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing dependencies" >&5
|
|
$as_echo "no, missing dependencies" >&6; }
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# dot is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=dot
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Cannot enable full docs with missing dependencies. See above. $HELP_MSG" "$LINENO" 5
|
|
else
|
|
ENABLE_FULL_DOCS=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
fi
|
|
elif test "x$enable_full_docs" = xno; then
|
|
ENABLE_FULL_DOCS=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
elif test "x$enable_full_docs" = x; then
|
|
# Check for prerequisites
|
|
if test "x$FULL_DOCS_DEP_MISSING" = xtrue; then
|
|
ENABLE_FULL_DOCS=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing dependencies" >&5
|
|
$as_echo "no, missing dependencies" >&6; }
|
|
else
|
|
ENABLE_FULL_DOCS=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, dependencies present" >&5
|
|
$as_echo "yes, dependencies present" >&6; }
|
|
fi
|
|
else
|
|
as_fn_error $? "--enable-full-docs can only take yes or no" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Choose cacerts source file
|
|
|
|
# Check whether --with-cacerts-file was given.
|
|
if test "${with_cacerts_file+set}" = set; then :
|
|
withval=$with_cacerts_file;
|
|
fi
|
|
|
|
if test "x$with_cacerts_file" != x; then
|
|
CACERTS_FILE=$with_cacerts_file
|
|
fi
|
|
|
|
|
|
# Enable or disable unlimited crypto
|
|
# Check whether --enable-unlimited-crypto was given.
|
|
if test "${enable_unlimited_crypto+set}" = set; then :
|
|
enableval=$enable_unlimited_crypto;
|
|
else
|
|
enable_unlimited_crypto=yes
|
|
fi
|
|
|
|
if test "x$enable_unlimited_crypto" = "xyes"; then
|
|
UNLIMITED_CRYPTO=true
|
|
else
|
|
UNLIMITED_CRYPTO=false
|
|
fi
|
|
|
|
|
|
# Should we build the serviceability agent (SA)?
|
|
INCLUDE_SA=true
|
|
if [[ " $JVM_VARIANTS " =~ " zero " ]] || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
INCLUDE_SA=false
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xaix ; then
|
|
INCLUDE_SA=false
|
|
fi
|
|
|
|
|
|
# Compress jars
|
|
COMPRESS_JARS=false
|
|
|
|
|
|
|
|
# Setup default copyright year. Mostly overridden when building close to a new year.
|
|
|
|
# Check whether --with-copyright-year was given.
|
|
if test "${with_copyright_year+set}" = set; then :
|
|
withval=$with_copyright_year;
|
|
fi
|
|
|
|
if test "x$with_copyright_year" = xyes; then
|
|
as_fn_error $? "Copyright year must have a value" "$LINENO" 5
|
|
elif test "x$with_copyright_year" != x; then
|
|
COPYRIGHT_YEAR="$with_copyright_year"
|
|
else
|
|
COPYRIGHT_YEAR=`$DATE +'%Y'`
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --enable-keep-packaged-modules was given.
|
|
if test "${enable_keep_packaged_modules+set}" = set; then :
|
|
enableval=$enable_keep_packaged_modules;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if packaged modules are kept" >&5
|
|
$as_echo_n "checking if packaged modules are kept... " >&6; }
|
|
if test "x$enable_keep_packaged_modules" = "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
JLINK_KEEP_PACKAGED_MODULES=true
|
|
elif test "x$enable_keep_packaged_modules" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
JLINK_KEEP_PACKAGED_MODULES=false
|
|
elif test "x$enable_keep_packaged_modules" = "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
|
|
$as_echo "yes (default)" >&6; }
|
|
JLINK_KEEP_PACKAGED_MODULES=true
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: error" >&5
|
|
$as_echo "error" >&6; }
|
|
as_fn_error $? "--enable-keep-packaged-modules accepts no argument" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Warn user that old version arguments are deprecated.
|
|
|
|
|
|
# Check whether --with-milestone was given.
|
|
if test "${with_milestone+set}" = set; then :
|
|
withval=$with_milestone; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-milestone is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-milestone is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-update-version was given.
|
|
if test "${with_update_version+set}" = set; then :
|
|
withval=$with_update_version; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-update-version is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-update-version is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-user-release-suffix was given.
|
|
if test "${with_user_release_suffix+set}" = set; then :
|
|
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
|
|
$as_echo "$as_me: WARNING: Option --with-user-release-suffix is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-build-number was given.
|
|
if test "${with_build_number+set}" = set; then :
|
|
withval=$with_build_number; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-build-number is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-build-number is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
# Source the version numbers file
|
|
. $AUTOCONF_DIR/version-numbers
|
|
|
|
# Some non-version number information is set in that file
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Override version from arguments
|
|
|
|
# If --with-version-string is set, process it first. It is possible to
|
|
# override parts with more specific flags, since these are processed later.
|
|
|
|
# Check whether --with-version-string was given.
|
|
if test "${with_version_string+set}" = set; then :
|
|
withval=$with_version_string;
|
|
fi
|
|
|
|
if test "x$with_version_string" = xyes; then
|
|
as_fn_error $? "--with-version-string must have a value" "$LINENO" 5
|
|
elif test "x$with_version_string" != x; then
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if [[ $with_version_string =~ ^([0-9]+)(\.([0-9]+))?(\.([0-9]+))?(\.([0-9]+))?(-([a-zA-Z]+))?((\+)([0-9]+)?(-([-a-zA-Z0-9.]+))?)?$ ]] ; then
|
|
VERSION_MAJOR=${BASH_REMATCH[1]}
|
|
VERSION_MINOR=${BASH_REMATCH[3]}
|
|
VERSION_SECURITY=${BASH_REMATCH[5]}
|
|
VERSION_PATCH=${BASH_REMATCH[7]}
|
|
VERSION_PRE=${BASH_REMATCH[9]}
|
|
version_plus_separator=${BASH_REMATCH[11]}
|
|
VERSION_BUILD=${BASH_REMATCH[12]}
|
|
VERSION_OPT=${BASH_REMATCH[14]}
|
|
# Unspecified numerical fields are interpreted as 0.
|
|
if test "x$VERSION_MINOR" = x; then
|
|
VERSION_MINOR=0
|
|
fi
|
|
if test "x$VERSION_SECURITY" = x; then
|
|
VERSION_SECURITY=0
|
|
fi
|
|
if test "x$VERSION_PATCH" = x; then
|
|
VERSION_PATCH=0
|
|
fi
|
|
if test "x$version_plus_separator" != x \
|
|
&& test "x$VERSION_BUILD$VERSION_OPT" = x; then
|
|
as_fn_error $? "Version string contains + but both 'BUILD' and 'OPT' are missing" "$LINENO" 5
|
|
fi
|
|
# Stop the version part process from setting default values.
|
|
# We still allow them to explicitly override though.
|
|
NO_DEFAULT_VERSION_PARTS=true
|
|
else
|
|
as_fn_error $? "--with-version-string fails to parse as a valid version string: $with_version_string" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-pre was given.
|
|
if test "${with_version_pre+set}" = set; then :
|
|
withval=$with_version_pre; with_version_pre_present=true
|
|
else
|
|
with_version_pre_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_pre_present" = xtrue; then
|
|
if test "x$with_version_pre" = xyes; then
|
|
as_fn_error $? "--with-version-pre must have a value" "$LINENO" 5
|
|
elif test "x$with_version_pre" = xno; then
|
|
# Interpret --without-* as empty string instead of the literal "no"
|
|
VERSION_PRE=
|
|
else
|
|
# Only [a-zA-Z] is allowed in the VERSION_PRE. Outer [ ] to quote m4.
|
|
VERSION_PRE=`$ECHO "$with_version_pre" | $TR -c -d '[a-z][A-Z]'`
|
|
if test "x$VERSION_PRE" != "x$with_version_pre"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&5
|
|
$as_echo "$as_me: WARNING: --with-version-pre value has been sanitized from '$with_version_pre' to '$VERSION_PRE'" >&2;}
|
|
fi
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is to use "internal" as pre
|
|
VERSION_PRE="internal"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-opt was given.
|
|
if test "${with_version_opt+set}" = set; then :
|
|
withval=$with_version_opt; with_version_opt_present=true
|
|
else
|
|
with_version_opt_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_opt_present" = xtrue; then
|
|
if test "x$with_version_opt" = xyes; then
|
|
as_fn_error $? "--with-version-opt must have a value" "$LINENO" 5
|
|
elif test "x$with_version_opt" = xno; then
|
|
# Interpret --without-* as empty string instead of the literal "no"
|
|
VERSION_OPT=
|
|
else
|
|
# Only [-.a-zA-Z0-9] is allowed in the VERSION_OPT. Outer [ ] to quote m4.
|
|
VERSION_OPT=`$ECHO "$with_version_opt" | $TR -c -d '[a-z][A-Z][0-9].-'`
|
|
if test "x$VERSION_OPT" != "x$with_version_opt"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&5
|
|
$as_echo "$as_me: WARNING: --with-version-opt value has been sanitized from '$with_version_opt' to '$VERSION_OPT'" >&2;}
|
|
fi
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is to calculate a string like this 'adhoc.<username>.<base dir name>'
|
|
# Outer [ ] to quote m4.
|
|
basedirname=`$BASENAME "$TOPDIR" | $TR -d -c '[a-z][A-Z][0-9].-'`
|
|
VERSION_OPT="adhoc.$USERNAME.$basedirname"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-build was given.
|
|
if test "${with_version_build+set}" = set; then :
|
|
withval=$with_version_build; with_version_build_present=true
|
|
else
|
|
with_version_build_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_build_present" = xtrue; then
|
|
if test "x$with_version_build" = xyes; then
|
|
as_fn_error $? "--with-version-build must have a value" "$LINENO" 5
|
|
elif test "x$with_version_build" = xno; then
|
|
# Interpret --without-* as empty string instead of the literal "no"
|
|
VERSION_BUILD=
|
|
elif test "x$with_version_build" = x; then
|
|
VERSION_BUILD=
|
|
else
|
|
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if ! [[ "$with_version_build" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
|
|
as_fn_error $? "\"$with_version_build\" is not a valid numerical value for VERSION_BUILD" "$LINENO" 5
|
|
fi
|
|
# Extract the version number without leading zeros.
|
|
cleaned_value=${BASH_REMATCH[1]}
|
|
if test "x$cleaned_value" = x; then
|
|
# Special case for zero
|
|
cleaned_value=${BASH_REMATCH[2]}
|
|
fi
|
|
|
|
if test $cleaned_value -gt 255; then
|
|
as_fn_error $? "VERSION_BUILD is given as $with_version_build. This is greater than 255 which is not allowed." "$LINENO" 5
|
|
fi
|
|
if test "x$cleaned_value" != "x$with_version_build"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&5
|
|
$as_echo "$as_me: WARNING: Value for VERSION_BUILD has been sanitized from '$with_version_build' to '$cleaned_value'" >&2;}
|
|
fi
|
|
VERSION_BUILD=$cleaned_value
|
|
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is to not have a build number.
|
|
VERSION_BUILD=""
|
|
# FIXME: Until all code can cope with an empty VERSION_BUILD, set it to 0.
|
|
VERSION_BUILD=0
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-major was given.
|
|
if test "${with_version_major+set}" = set; then :
|
|
withval=$with_version_major; with_version_major_present=true
|
|
else
|
|
with_version_major_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_major_present" = xtrue; then
|
|
if test "x$with_version_major" = xyes; then
|
|
as_fn_error $? "--with-version-major must have a value" "$LINENO" 5
|
|
else
|
|
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if ! [[ "$with_version_major" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
|
|
as_fn_error $? "\"$with_version_major\" is not a valid numerical value for VERSION_MAJOR" "$LINENO" 5
|
|
fi
|
|
# Extract the version number without leading zeros.
|
|
cleaned_value=${BASH_REMATCH[1]}
|
|
if test "x$cleaned_value" = x; then
|
|
# Special case for zero
|
|
cleaned_value=${BASH_REMATCH[2]}
|
|
fi
|
|
|
|
if test $cleaned_value -gt 255; then
|
|
as_fn_error $? "VERSION_MAJOR is given as $with_version_major. This is greater than 255 which is not allowed." "$LINENO" 5
|
|
fi
|
|
if test "x$cleaned_value" != "x$with_version_major"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&5
|
|
$as_echo "$as_me: WARNING: Value for VERSION_MAJOR has been sanitized from '$with_version_major' to '$cleaned_value'" >&2;}
|
|
fi
|
|
VERSION_MAJOR=$cleaned_value
|
|
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is to get value from version-numbers
|
|
VERSION_MAJOR="$DEFAULT_VERSION_MAJOR"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-minor was given.
|
|
if test "${with_version_minor+set}" = set; then :
|
|
withval=$with_version_minor; with_version_minor_present=true
|
|
else
|
|
with_version_minor_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_minor_present" = xtrue; then
|
|
if test "x$with_version_minor" = xyes; then
|
|
as_fn_error $? "--with-version-minor must have a value" "$LINENO" 5
|
|
elif test "x$with_version_minor" = xno; then
|
|
# Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
|
|
VERSION_MINOR=0
|
|
elif test "x$with_version_minor" = x; then
|
|
VERSION_MINOR=0
|
|
else
|
|
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if ! [[ "$with_version_minor" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
|
|
as_fn_error $? "\"$with_version_minor\" is not a valid numerical value for VERSION_MINOR" "$LINENO" 5
|
|
fi
|
|
# Extract the version number without leading zeros.
|
|
cleaned_value=${BASH_REMATCH[1]}
|
|
if test "x$cleaned_value" = x; then
|
|
# Special case for zero
|
|
cleaned_value=${BASH_REMATCH[2]}
|
|
fi
|
|
|
|
if test $cleaned_value -gt 255; then
|
|
as_fn_error $? "VERSION_MINOR is given as $with_version_minor. This is greater than 255 which is not allowed." "$LINENO" 5
|
|
fi
|
|
if test "x$cleaned_value" != "x$with_version_minor"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&5
|
|
$as_echo "$as_me: WARNING: Value for VERSION_MINOR has been sanitized from '$with_version_minor' to '$cleaned_value'" >&2;}
|
|
fi
|
|
VERSION_MINOR=$cleaned_value
|
|
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is 0, if unspecified
|
|
VERSION_MINOR=$DEFAULT_VERSION_MINOR
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-security was given.
|
|
if test "${with_version_security+set}" = set; then :
|
|
withval=$with_version_security; with_version_security_present=true
|
|
else
|
|
with_version_security_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_security_present" = xtrue; then
|
|
if test "x$with_version_security" = xyes; then
|
|
as_fn_error $? "--with-version-security must have a value" "$LINENO" 5
|
|
elif test "x$with_version_security" = xno; then
|
|
# Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
|
|
VERSION_SECURITY=0
|
|
elif test "x$with_version_security" = x; then
|
|
VERSION_SECURITY=0
|
|
else
|
|
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if ! [[ "$with_version_security" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
|
|
as_fn_error $? "\"$with_version_security\" is not a valid numerical value for VERSION_SECURITY" "$LINENO" 5
|
|
fi
|
|
# Extract the version number without leading zeros.
|
|
cleaned_value=${BASH_REMATCH[1]}
|
|
if test "x$cleaned_value" = x; then
|
|
# Special case for zero
|
|
cleaned_value=${BASH_REMATCH[2]}
|
|
fi
|
|
|
|
if test $cleaned_value -gt 255; then
|
|
as_fn_error $? "VERSION_SECURITY is given as $with_version_security. This is greater than 255 which is not allowed." "$LINENO" 5
|
|
fi
|
|
if test "x$cleaned_value" != "x$with_version_security"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&5
|
|
$as_echo "$as_me: WARNING: Value for VERSION_SECURITY has been sanitized from '$with_version_security' to '$cleaned_value'" >&2;}
|
|
fi
|
|
VERSION_SECURITY=$cleaned_value
|
|
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is 0, if unspecified
|
|
VERSION_SECURITY=$DEFAULT_VERSION_SECURITY
|
|
fi
|
|
fi
|
|
|
|
|
|
# Check whether --with-version-patch was given.
|
|
if test "${with_version_patch+set}" = set; then :
|
|
withval=$with_version_patch; with_version_patch_present=true
|
|
else
|
|
with_version_patch_present=false
|
|
fi
|
|
|
|
|
|
if test "x$with_version_patch_present" = xtrue; then
|
|
if test "x$with_version_patch" = xyes; then
|
|
as_fn_error $? "--with-version-patch must have a value" "$LINENO" 5
|
|
elif test "x$with_version_patch" = xno; then
|
|
# Interpret --without-* as empty string (i.e. 0) instead of the literal "no"
|
|
VERSION_PATCH=0
|
|
elif test "x$with_version_patch" = x; then
|
|
VERSION_PATCH=0
|
|
else
|
|
|
|
# Additional [] needed to keep m4 from mangling shell constructs.
|
|
if ! [[ "$with_version_patch" =~ ^0*([1-9][0-9]*)|(0)$ ]] ; then
|
|
as_fn_error $? "\"$with_version_patch\" is not a valid numerical value for VERSION_PATCH" "$LINENO" 5
|
|
fi
|
|
# Extract the version number without leading zeros.
|
|
cleaned_value=${BASH_REMATCH[1]}
|
|
if test "x$cleaned_value" = x; then
|
|
# Special case for zero
|
|
cleaned_value=${BASH_REMATCH[2]}
|
|
fi
|
|
|
|
if test $cleaned_value -gt 255; then
|
|
as_fn_error $? "VERSION_PATCH is given as $with_version_patch. This is greater than 255 which is not allowed." "$LINENO" 5
|
|
fi
|
|
if test "x$cleaned_value" != "x$with_version_patch"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&5
|
|
$as_echo "$as_me: WARNING: Value for VERSION_PATCH has been sanitized from '$with_version_patch' to '$cleaned_value'" >&2;}
|
|
fi
|
|
VERSION_PATCH=$cleaned_value
|
|
|
|
fi
|
|
else
|
|
if test "x$NO_DEFAULT_VERSION_PARTS" != xtrue; then
|
|
# Default is 0, if unspecified
|
|
VERSION_PATCH=$DEFAULT_VERSION_PATCH
|
|
fi
|
|
fi
|
|
|
|
# Calculate derived version properties
|
|
|
|
# Set VERSION_IS_GA based on if VERSION_PRE has a value
|
|
if test "x$VERSION_PRE" = x; then
|
|
VERSION_IS_GA=true
|
|
else
|
|
VERSION_IS_GA=false
|
|
fi
|
|
|
|
# VERSION_NUMBER but always with exactly 4 positions, with 0 for empty positions.
|
|
VERSION_NUMBER_FOUR_POSITIONS=$VERSION_MAJOR.$VERSION_MINOR.$VERSION_SECURITY.$VERSION_PATCH
|
|
|
|
stripped_version_number=$VERSION_NUMBER_FOUR_POSITIONS
|
|
# Strip trailing zeroes from stripped_version_number
|
|
for i in 1 2 3 ; do stripped_version_number=${stripped_version_number%.0} ; done
|
|
VERSION_NUMBER=$stripped_version_number
|
|
|
|
# The complete version string, with additional build information
|
|
if test "x$VERSION_BUILD$VERSION_OPT" = x; then
|
|
VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
|
|
else
|
|
# If either build or opt is set, we need a + separator
|
|
VERSION_STRING=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}+$VERSION_BUILD${VERSION_OPT:+-$VERSION_OPT}
|
|
fi
|
|
|
|
# The short version string, just VERSION_NUMBER and PRE, if present.
|
|
VERSION_SHORT=$VERSION_NUMBER${VERSION_PRE:+-$VERSION_PRE}
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for version string" >&5
|
|
$as_echo_n "checking for version string... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $VERSION_STRING" >&5
|
|
$as_echo "$VERSION_STRING" >&6; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Setup BootJDK, used to bootstrap the build.
|
|
#
|
|
###############################################################################
|
|
|
|
|
|
BOOT_JDK_FOUND=no
|
|
|
|
# Check whether --with-boot-jdk was given.
|
|
if test "${with_boot_jdk+set}" = set; then :
|
|
withval=$with_boot_jdk;
|
|
fi
|
|
|
|
|
|
# We look for the Boot JDK through various means, going from more certain to
|
|
# more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
|
|
# we detected something (if so, the path to the jdk is in BOOT_JDK). But we
|
|
# must check if this is indeed valid; otherwise we'll continue looking.
|
|
|
|
# Test: Is bootjdk explicitly set by command line arguments?
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$with_boot_jdk" != x; then
|
|
BOOT_JDK=$with_boot_jdk
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Having specified an argument which is incorrect will produce an instant failure;
|
|
# we should not go on looking
|
|
as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# First check at user selected default
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test -x /usr/libexec/java_home; then
|
|
BOOT_JDK=`/usr/libexec/java_home `
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
# If that did not work out (e.g. too old), try explicit versions instead
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test -x /usr/libexec/java_home; then
|
|
BOOT_JDK=`/usr/libexec/java_home -v 1.9`
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test -x /usr/libexec/java_home; then
|
|
BOOT_JDK=`/usr/libexec/java_home -v 1.8`
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test -x /usr/libexec/java_home; then
|
|
BOOT_JDK=`/usr/libexec/java_home -v 1.7`
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
# Test: Is $JAVA_HOME set?
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$JAVA_HOME" != x; then
|
|
JAVA_HOME_PROCESSED="$JAVA_HOME"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$JAVA_HOME_PROCESSED" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$JAVA_HOME_PROCESSED"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
JAVA_HOME_PROCESSED="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$JAVA_HOME_PROCESSED"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
JAVA_HOME_PROCESSED="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$JAVA_HOME_PROCESSED"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
JAVA_HOME_PROCESSED="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test ! -d "$JAVA_HOME_PROCESSED"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
|
|
$as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
|
|
else
|
|
# Aha, the user has set a JAVA_HOME
|
|
# let us use that as the Boot JDK.
|
|
BOOT_JDK="$JAVA_HOME_PROCESSED"
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
# Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
# Extract the first word of "javac", so it can be a program name with args.
|
|
set dummy javac; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JAVAC_CHECK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JAVAC_CHECK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
|
|
if test -n "$JAVAC_CHECK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
|
|
$as_echo "$JAVAC_CHECK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
# Extract the first word of "java", so it can be a program name with args.
|
|
set dummy java; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JAVA_CHECK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JAVA_CHECK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JAVA_CHECK=$ac_cv_path_JAVA_CHECK
|
|
if test -n "$JAVA_CHECK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
|
|
$as_echo "$JAVA_CHECK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
BINARY="$JAVAC_CHECK"
|
|
if test "x$JAVAC_CHECK" = x; then
|
|
BINARY="$JAVA_CHECK"
|
|
fi
|
|
if test "x$BINARY" != x; then
|
|
# So there is a java(c) binary, it might be part of a JDK.
|
|
# Lets find the JDK/JRE directory by following symbolic links.
|
|
# Linux/GNU systems often have links from /usr/bin/java to
|
|
# /etc/alternatives/java to the real JDK binary.
|
|
|
|
if test "x$OPENJDK_BUILD_OS" != xwindows; then
|
|
# Follow a chain of symbolic links. Use readlink
|
|
# where it exists, else fall back to horribly
|
|
# complicated shell code.
|
|
if test "x$READLINK_TESTED" != yes; then
|
|
# On MacOSX there is a readlink tool with a different
|
|
# purpose than the GNU readlink tool. Check the found readlink.
|
|
ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
|
|
if test "x$ISGNU" = x; then
|
|
# A readlink that we do not know how to use.
|
|
# Are there other non-GNU readlinks out there?
|
|
READLINK_TESTED=yes
|
|
READLINK=
|
|
fi
|
|
fi
|
|
|
|
if test "x$READLINK" != x; then
|
|
BINARY=`$READLINK -f $BINARY`
|
|
else
|
|
# Save the current directory for restoring afterwards
|
|
STARTDIR=$PWD
|
|
COUNTER=0
|
|
sym_link_dir=`$DIRNAME $BINARY`
|
|
sym_link_file=`$BASENAME $BINARY`
|
|
cd $sym_link_dir
|
|
# Use -P flag to resolve symlinks in directories.
|
|
cd `$THEPWDCMD -P`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
# Resolve file symlinks
|
|
while test $COUNTER -lt 20; do
|
|
ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
|
|
if test "x$ISLINK" == x; then
|
|
# This is not a symbolic link! We are done!
|
|
break
|
|
fi
|
|
# Again resolve directory symlinks since the target of the just found
|
|
# link could be in a different directory
|
|
cd `$DIRNAME $ISLINK`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
sym_link_file=`$BASENAME $ISLINK`
|
|
let COUNTER=COUNTER+1
|
|
done
|
|
cd $STARTDIR
|
|
BINARY=$sym_link_dir/$sym_link_file
|
|
fi
|
|
fi
|
|
|
|
BOOT_JDK=`dirname "$BINARY"`
|
|
BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
|
|
if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
|
|
# Looks like we found ourselves an JDK
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
# Test: Is there a JDK installed in default, well-known locations?
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$ProgramW6432" != x; then
|
|
VIRTUAL_DIR="$ProgramW6432/Java"
|
|
|
|
windows_path="$VIRTUAL_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VIRTUAL_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VIRTUAL_DIR="$unix_path"
|
|
fi
|
|
|
|
|
|
BOOT_JDK_PREFIX="$VIRTUAL_DIR"
|
|
BOOT_JDK_SUFFIX=""
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$PROGRAMW6432" != x; then
|
|
VIRTUAL_DIR="$PROGRAMW6432/Java"
|
|
|
|
windows_path="$VIRTUAL_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VIRTUAL_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VIRTUAL_DIR="$unix_path"
|
|
fi
|
|
|
|
|
|
BOOT_JDK_PREFIX="$VIRTUAL_DIR"
|
|
BOOT_JDK_SUFFIX=""
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$PROGRAMFILES" != x; then
|
|
VIRTUAL_DIR="$PROGRAMFILES/Java"
|
|
|
|
windows_path="$VIRTUAL_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VIRTUAL_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VIRTUAL_DIR="$unix_path"
|
|
fi
|
|
|
|
|
|
BOOT_JDK_PREFIX="$VIRTUAL_DIR"
|
|
BOOT_JDK_SUFFIX=""
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
if test "x$ProgramFiles" != x; then
|
|
VIRTUAL_DIR="$ProgramFiles/Java"
|
|
|
|
windows_path="$VIRTUAL_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VIRTUAL_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VIRTUAL_DIR="$unix_path"
|
|
fi
|
|
|
|
|
|
BOOT_JDK_PREFIX="$VIRTUAL_DIR"
|
|
BOOT_JDK_SUFFIX=""
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
|
|
BOOT_JDK_SUFFIX=""
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
|
|
BOOT_JDK_SUFFIX="/Contents/Home"
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
|
|
BOOT_JDK_SUFFIX="/Contents/Home"
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK_PREFIX="/usr/lib/jvm"
|
|
BOOT_JDK_SUFFIX=""
|
|
ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
|
|
if test "x$ALL_JDKS_FOUND" != x; then
|
|
for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
|
|
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
# Now execute the test
|
|
|
|
BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
|
|
if test -d "$BOOT_JDK"; then
|
|
BOOT_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
|
|
$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BOOT_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BOOT_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Do we have a bin/javac?
|
|
if test ! -x "$BOOT_JDK/bin/javac"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"|(1\.[89]\.)'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
|
|
$as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
|
|
BOOT_JDK_FOUND=no
|
|
else
|
|
# We're done! :-)
|
|
BOOT_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BOOT_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BOOT_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BOOT_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BOOT_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BOOT_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BOOT_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
|
|
$as_echo_n "checking for Boot JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
|
|
$as_echo "$BOOT_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
|
|
$as_echo_n "checking Boot JDK version... " >&6; }
|
|
BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
|
|
$as_echo "$BOOT_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check javac
|
|
fi # end check java
|
|
fi # end check boot jdk found
|
|
fi
|
|
|
|
|
|
# If we haven't found anything yet, we've truly lost. Give up.
|
|
if test "x$BOOT_JDK_FOUND" = xno; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# openjdk is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=openjdk
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
|
|
$as_echo "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Cannot continue" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Setup tools from the Boot JDK.
|
|
|
|
# Use user overridden value if available, otherwise locate tool in the Boot JDK.
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${JAVA+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
|
|
$as_echo_n "checking for java in Boot JDK... " >&6; }
|
|
JAVA=$BOOT_JDK/bin/java
|
|
if test ! -x $JAVA; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !JAVA! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAVA!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xJAVA" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAVA from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of JAVA from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
|
|
$as_echo_n "checking for java in Boot JDK... " >&6; }
|
|
JAVA=$BOOT_JDK/bin/java
|
|
if test ! -x $JAVA; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$JAVA" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAVA= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool JAVA= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVA" >&5
|
|
$as_echo_n "checking for JAVA... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$JAVA"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAVA=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool JAVA=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JAVA+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JAVA in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JAVA="$JAVA" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JAVA="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JAVA=$ac_cv_path_JAVA
|
|
if test -n "$JAVA"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA" >&5
|
|
$as_echo "$JAVA" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$JAVA" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAVA=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool JAVA=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVA" >&5
|
|
$as_echo_n "checking for JAVA... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool JAVA=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Use user overridden value if available, otherwise locate tool in the Boot JDK.
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${JAVAC+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
|
|
$as_echo_n "checking for javac in Boot JDK... " >&6; }
|
|
JAVAC=$BOOT_JDK/bin/javac
|
|
if test ! -x $JAVAC; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !JAVAC! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAVAC!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xJAVAC" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAVAC from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of JAVAC from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
|
|
$as_echo_n "checking for javac in Boot JDK... " >&6; }
|
|
JAVAC=$BOOT_JDK/bin/javac
|
|
if test ! -x $JAVAC; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$JAVAC" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAVAC= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool JAVAC= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAC" >&5
|
|
$as_echo_n "checking for JAVAC... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$JAVAC"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAVAC=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool JAVAC=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JAVAC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JAVAC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JAVAC="$JAVAC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JAVAC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JAVAC=$ac_cv_path_JAVAC
|
|
if test -n "$JAVAC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC" >&5
|
|
$as_echo "$JAVAC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$JAVAC" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAVAC=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool JAVAC=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAC" >&5
|
|
$as_echo_n "checking for JAVAC... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool JAVAC=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Use user overridden value if available, otherwise locate tool in the Boot JDK.
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${JAVAH+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
|
|
$as_echo_n "checking for javah in Boot JDK... " >&6; }
|
|
JAVAH=$BOOT_JDK/bin/javah
|
|
if test ! -x $JAVAH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !JAVAH! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAVAH!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xJAVAH" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAVAH from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of JAVAH from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
|
|
$as_echo_n "checking for javah in Boot JDK... " >&6; }
|
|
JAVAH=$BOOT_JDK/bin/javah
|
|
if test ! -x $JAVAH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$JAVAH" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAVAH= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool JAVAH= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAH" >&5
|
|
$as_echo_n "checking for JAVAH... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$JAVAH"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAVAH=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool JAVAH=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JAVAH+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JAVAH in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JAVAH="$JAVAH" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JAVAH="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JAVAH=$ac_cv_path_JAVAH
|
|
if test -n "$JAVAH"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAH" >&5
|
|
$as_echo "$JAVAH" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$JAVAH" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAVAH=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool JAVAH=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAVAH" >&5
|
|
$as_echo_n "checking for JAVAH... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool JAVAH=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Use user overridden value if available, otherwise locate tool in the Boot JDK.
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${JAR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
|
|
$as_echo_n "checking for jar in Boot JDK... " >&6; }
|
|
JAR=$BOOT_JDK/bin/jar
|
|
if test ! -x $JAR; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !JAR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JAR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xJAR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JAR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of JAR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
|
|
$as_echo_n "checking for jar in Boot JDK... " >&6; }
|
|
JAR=$BOOT_JDK/bin/jar
|
|
if test ! -x $JAR; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$JAR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JAR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool JAR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAR" >&5
|
|
$as_echo_n "checking for JAR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$JAR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JAR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool JAR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JAR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JAR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JAR="$JAR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JAR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JAR=$ac_cv_path_JAR
|
|
if test -n "$JAR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5
|
|
$as_echo "$JAR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$JAR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JAR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool JAR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JAR" >&5
|
|
$as_echo_n "checking for JAR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool JAR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Use user overridden value if available, otherwise locate tool in the Boot JDK.
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${JARSIGNER+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jarsigner in Boot JDK" >&5
|
|
$as_echo_n "checking for jarsigner in Boot JDK... " >&6; }
|
|
JARSIGNER=$BOOT_JDK/bin/jarsigner
|
|
if test ! -x $JARSIGNER; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find jarsigner in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !JARSIGNER! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JARSIGNER!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xJARSIGNER" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JARSIGNER from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of JARSIGNER from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jarsigner in Boot JDK" >&5
|
|
$as_echo_n "checking for jarsigner in Boot JDK... " >&6; }
|
|
JARSIGNER=$BOOT_JDK/bin/jarsigner
|
|
if test ! -x $JARSIGNER; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&5
|
|
$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk" >&6;}
|
|
as_fn_error $? "Could not find jarsigner in the Boot JDK" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$JARSIGNER" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JARSIGNER= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool JARSIGNER= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JARSIGNER" >&5
|
|
$as_echo_n "checking for JARSIGNER... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$JARSIGNER"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JARSIGNER=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool JARSIGNER=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JARSIGNER+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JARSIGNER in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JARSIGNER="$JARSIGNER" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JARSIGNER="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JARSIGNER=$ac_cv_path_JARSIGNER
|
|
if test -n "$JARSIGNER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JARSIGNER" >&5
|
|
$as_echo "$JARSIGNER" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$JARSIGNER" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JARSIGNER=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool JARSIGNER=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JARSIGNER" >&5
|
|
$as_echo_n "checking for JARSIGNER... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool JARSIGNER=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Finally, set some other options...
|
|
|
|
# When compiling code to be executed by the Boot JDK, force jdk8 compatibility.
|
|
BOOT_JDK_SOURCETARGET="-source 8 -target 8"
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK supports modules" >&5
|
|
$as_echo_n "checking if Boot JDK supports modules... " >&6; }
|
|
if "$JAVA" --list-modules > /dev/null 2>&1; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
BOOT_JDK_MODULAR="true"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
BOOT_JDK_MODULAR="false"
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check if the boot jdk is 32 or 64 bit
|
|
if "$JAVA" -version 2>&1 | $GREP -q "64-Bit"; then
|
|
BOOT_JDK_BITS="64"
|
|
else
|
|
BOOT_JDK_BITS="32"
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
|
|
$as_echo_n "checking if Boot JDK is 32 or 64 bits... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
|
|
$as_echo "$BOOT_JDK_BITS" >&6; }
|
|
|
|
|
|
|
|
# Check whether --with-build-jdk was given.
|
|
if test "${with_build_jdk+set}" = set; then :
|
|
withval=$with_build_jdk;
|
|
fi
|
|
|
|
|
|
CREATE_BUILDJDK=false
|
|
EXTERNAL_BUILDJDK=false
|
|
BUILD_JDK_FOUND="no"
|
|
if test "x$with_build_jdk" != "x"; then
|
|
|
|
if test "x$BUILD_JDK_FOUND" = xno; then
|
|
# Execute the test
|
|
|
|
if test "x$with_build_jdk" != x; then
|
|
BUILD_JDK=$with_build_jdk
|
|
BUILD_JDK_FOUND=maybe
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Build JDK using configure arguments" >&5
|
|
$as_echo "$as_me: Found potential Build JDK using configure arguments" >&6;}
|
|
fi
|
|
|
|
# If previous step claimed to have found a JDK, check it to see if it seems to be valid.
|
|
if test "x$BUILD_JDK_FOUND" = xmaybe; then
|
|
# Do we have a bin/java?
|
|
if test ! -x "$BUILD_JDK/bin/java"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/java; ignoring" >&5
|
|
$as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/java; ignoring" >&6;}
|
|
BUILD_JDK_FOUND=no
|
|
elif test ! -x "$BUILD_JDK/bin/jlink"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/jlink; ignoring" >&5
|
|
$as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/jlink; ignoring" >&6;}
|
|
BUILD_JDK_FOUND=no
|
|
elif test ! -x "$BUILD_JDK/bin/jmod"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/jmod; ignoring" >&5
|
|
$as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/jmod; ignoring" >&6;}
|
|
BUILD_JDK_FOUND=no
|
|
elif test ! -x "$BUILD_JDK/bin/javac"; then
|
|
# Do we have a bin/javac?
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK did not contain bin/javac; ignoring" >&5
|
|
$as_echo "$as_me: Potential Build JDK found at $BUILD_JDK did not contain bin/javac; ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (This might be a JRE instead of an JDK)" >&5
|
|
$as_echo "$as_me: (This might be a JRE instead of an JDK)" >&6;}
|
|
BUILD_JDK_FOUND=no
|
|
else
|
|
# Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
|
|
BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
|
|
|
|
# Extra M4 quote needed to protect [] in grep expression.
|
|
FOUND_CORRECT_VERSION=`echo $BUILD_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"'`
|
|
if test "x$FOUND_CORRECT_VERSION" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Potential Build JDK found at $BUILD_JDK is incorrect JDK version ($BUILD_JDK_VERSION); ignoring" >&5
|
|
$as_echo "$as_me: Potential Build JDK found at $BUILD_JDK is incorrect JDK version ($BUILD_JDK_VERSION); ignoring" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: (Your Build JDK must be version 9)" >&5
|
|
$as_echo "$as_me: (Your Build JDK must be version 9)" >&6;}
|
|
BUILD_JDK_FOUND=no
|
|
else
|
|
# We're done!
|
|
BUILD_JDK_FOUND=yes
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_JDK" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$BUILD_JDK"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_JDK" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BUILD_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$BUILD_JDK"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
BUILD_JDK="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_JDK to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_JDK to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$BUILD_JDK"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_JDK, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of BUILD_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
BUILD_JDK="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
BUILD_JDK="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
|
|
$as_echo_n "checking for Build JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_JDK" >&5
|
|
$as_echo "$BUILD_JDK" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Build JDK version" >&5
|
|
$as_echo_n "checking Build JDK version... " >&6; }
|
|
BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_JDK_VERSION" >&5
|
|
$as_echo "$BUILD_JDK_VERSION" >&6; }
|
|
fi # end check jdk version
|
|
fi # end check java
|
|
fi # end check build jdk found
|
|
fi
|
|
|
|
EXTERNAL_BUILDJDK=true
|
|
else
|
|
if test "x$COMPILE_TYPE" = "xcross"; then
|
|
BUILD_JDK="\$(BUILDJDK_OUTPUTDIR)/jdk"
|
|
BUILD_JDK_FOUND=yes
|
|
CREATE_BUILDJDK=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
|
|
$as_echo_n "checking for Build JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, will build it for the host platform" >&5
|
|
$as_echo "yes, will build it for the host platform" >&6; }
|
|
else
|
|
BUILD_JDK="\$(JDK_OUTPUTDIR)"
|
|
BUILD_JDK_FOUND=yes
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
|
|
$as_echo_n "checking for Build JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, will use output dir" >&5
|
|
$as_echo "yes, will use output dir" >&6; }
|
|
fi
|
|
fi
|
|
|
|
JMOD="$BUILD_JDK/bin/jmod"
|
|
JLINK="$BUILD_JDK/bin/jlink"
|
|
|
|
|
|
|
|
if test "x$BUILD_JDK_FOUND" != "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Build JDK" >&5
|
|
$as_echo_n "checking for Build JDK... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
as_fn_error $? "Could not find a suitable Build JDK" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Configure the sources to use. We can add or override individual directories.
|
|
#
|
|
###############################################################################
|
|
|
|
|
|
# Where are the sources.
|
|
LANGTOOLS_TOPDIR="$SRC_ROOT/langtools"
|
|
CORBA_TOPDIR="$SRC_ROOT/corba"
|
|
JAXP_TOPDIR="$SRC_ROOT/jaxp"
|
|
JAXWS_TOPDIR="$SRC_ROOT/jaxws"
|
|
HOTSPOT_TOPDIR="$SRC_ROOT/hotspot"
|
|
NASHORN_TOPDIR="$SRC_ROOT/nashorn"
|
|
JDK_TOPDIR="$SRC_ROOT/jdk"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# This feature is no longer supported.
|
|
|
|
|
|
|
|
# Check whether --with-add-source-root was given.
|
|
if test "${with_add_source_root+set}" = set; then :
|
|
withval=$with_add_source_root; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-add-source-root is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-add-source-root is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-source-root was given.
|
|
if test "${with_override_source_root+set}" = set; then :
|
|
withval=$with_override_source_root; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-source-root is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-source-root is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-adds-and-overrides was given.
|
|
if test "${with_adds_and_overrides+set}" = set; then :
|
|
withval=$with_adds_and_overrides; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-adds-and-overrides is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-adds-and-overrides is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-langtools was given.
|
|
if test "${with_override_langtools+set}" = set; then :
|
|
withval=$with_override_langtools; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-langtools is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-langtools is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-corba was given.
|
|
if test "${with_override_corba+set}" = set; then :
|
|
withval=$with_override_corba; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-corba is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-corba is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-jaxp was given.
|
|
if test "${with_override_jaxp+set}" = set; then :
|
|
withval=$with_override_jaxp; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-jaxp is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-jaxp is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-jaxws was given.
|
|
if test "${with_override_jaxws+set}" = set; then :
|
|
withval=$with_override_jaxws; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-jaxws is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-jaxws is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-hotspot was given.
|
|
if test "${with_override_hotspot+set}" = set; then :
|
|
withval=$with_override_hotspot; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-hotspot is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-hotspot is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-nashorn was given.
|
|
if test "${with_override_nashorn+set}" = set; then :
|
|
withval=$with_override_nashorn; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-nashorn is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-nashorn is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-override-jdk was given.
|
|
if test "${with_override_jdk+set}" = set; then :
|
|
withval=$with_override_jdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-override-jdk is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-override-jdk is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
BUILD_OUTPUT="$OUTPUT_ROOT"
|
|
|
|
JDK_OUTPUTDIR="$OUTPUT_ROOT/jdk"
|
|
|
|
|
|
|
|
# Check whether --with-import_hotspot was given.
|
|
if test "${with_import_hotspot+set}" = set; then :
|
|
withval=$with_import_hotspot; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-import_hotspot is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-import_hotspot is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-import-modules was given.
|
|
if test "${with_import_modules+set}" = set; then :
|
|
withval=$with_import_modules;
|
|
fi
|
|
|
|
|
|
if test "x$with_import_modules" != x \
|
|
&& test "x$with_import_modules" != "xno"; then
|
|
if test -d "$with_import_modules"; then
|
|
IMPORT_MODULES_TOPDIR="$with_import_modules"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$IMPORT_MODULES_TOPDIR" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$IMPORT_MODULES_TOPDIR"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of IMPORT_MODULES_TOPDIR" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
IMPORT_MODULES_TOPDIR="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$IMPORT_MODULES_TOPDIR"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
IMPORT_MODULES_TOPDIR="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting IMPORT_MODULES_TOPDIR to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$IMPORT_MODULES_TOPDIR"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of IMPORT_MODULES_TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
IMPORT_MODULES_TOPDIR="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
IMPORT_MODULES_TOPDIR="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
elif test -e "$with_import_modules"; then
|
|
IMPORT_MODULES_TOPDIR="$CONFIGURESUPPORT_OUTPUTDIR/import-modules"
|
|
$RM -rf "$IMPORT_MODULES_TOPDIR"
|
|
$MKDIR -p "$IMPORT_MODULES_TOPDIR"
|
|
if ! $UNZIP -q "$with_import_modules" -d "$IMPORT_MODULES_TOPDIR"; then
|
|
as_fn_error $? "--with-import-modules=\"$with_import_modules\" must point to a dir or a zip file" "$LINENO" 5
|
|
fi
|
|
else
|
|
as_fn_error $? "--with-import-modules=\"$with_import_modules\" must point to a dir or a zip file" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules"; then
|
|
IMPORT_MODULES_CLASSES="$IMPORT_MODULES_TOPDIR/modules"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules_cmds"; then
|
|
IMPORT_MODULES_CMDS="$IMPORT_MODULES_TOPDIR/modules_cmds"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules_libs"; then
|
|
IMPORT_MODULES_LIBS="$IMPORT_MODULES_TOPDIR/modules_libs"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules_conf"; then
|
|
IMPORT_MODULES_CONF="$IMPORT_MODULES_TOPDIR/modules_conf"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules_legal"; then
|
|
IMPORT_MODULES_LEGAL="$IMPORT_MODULES_TOPDIR/modules_legal"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules_man"; then
|
|
IMPORT_MODULES_MAN="$IMPORT_MODULES_TOPDIR/modules_man"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/modules_src"; then
|
|
IMPORT_MODULES_SRC="$IMPORT_MODULES_TOPDIR/modules_src"
|
|
fi
|
|
if test -d "$IMPORT_MODULES_TOPDIR/make"; then
|
|
IMPORT_MODULES_MAKE="$IMPORT_MODULES_TOPDIR/make"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Setup the toolchain (compilers etc), i.e. tools used to compile and process
|
|
# native code.
|
|
#
|
|
###############################################################################
|
|
|
|
# See if we are doing a complete static build or not
|
|
|
|
# Check whether --enable-static-build was given.
|
|
if test "${enable_static_build+set}" = set; then :
|
|
enableval=$enable_static_build;
|
|
fi
|
|
|
|
STATIC_BUILD=false
|
|
if test "x$enable_static_build" = "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if static build is enabled" >&5
|
|
$as_echo_n "checking if static build is enabled... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
if test "x$OPENJDK_TARGET_OS" != "xmacosx"; then
|
|
as_fn_error $? "--enable-static-build is only supported for macosx builds" "$LINENO" 5
|
|
fi
|
|
STATIC_BUILD_CFLAGS="-DSTATIC_BUILD=1"
|
|
CFLAGS_JDKLIB_EXTRA="$CFLAGS_JDKLIB_EXTRA $STATIC_BUILD_CFLAGS"
|
|
CXXFLAGS_JDKLIB_EXTRA="$CXXFLAGS_JDKLIB_EXTRA $STATIC_BUILD_CFLAGS"
|
|
STATIC_BUILD=true
|
|
elif test "x$enable_static_build" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if static build is enabled" >&5
|
|
$as_echo_n "checking if static build is enabled... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
elif test "x$enable_static_build" != "x"; then
|
|
as_fn_error $? "--enable-static-build can only be assigned \"yes\" or \"no\"" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# First determine the toolchain type (compiler family)
|
|
|
|
|
|
# Check whether --with-toolchain-type was given.
|
|
if test "${with_toolchain_type+set}" = set; then :
|
|
withval=$with_toolchain_type;
|
|
fi
|
|
|
|
|
|
# Use indirect variable referencing
|
|
toolchain_var_name=VALID_TOOLCHAINS_$OPENJDK_BUILD_OS
|
|
VALID_TOOLCHAINS=${!toolchain_var_name}
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
if test -n "$XCODEBUILD"; then
|
|
# On Mac OS X, default toolchain to clang after Xcode 5
|
|
XCODE_VERSION_OUTPUT=`"$XCODEBUILD" -version 2>&1 | $HEAD -n 1`
|
|
$ECHO "$XCODE_VERSION_OUTPUT" | $GREP "Xcode " > /dev/null
|
|
if test $? -ne 0; then
|
|
as_fn_error $? "Failed to determine Xcode version." "$LINENO" 5
|
|
fi
|
|
XCODE_MAJOR_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | \
|
|
$SED -e 's/^Xcode \([1-9][0-9.]*\)/\1/' | \
|
|
$CUT -f 1 -d .`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Xcode major version: $XCODE_MAJOR_VERSION" >&5
|
|
$as_echo "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
|
|
if test $XCODE_MAJOR_VERSION -ge 5; then
|
|
DEFAULT_TOOLCHAIN="clang"
|
|
else
|
|
DEFAULT_TOOLCHAIN="gcc"
|
|
fi
|
|
else
|
|
# If Xcode is not installed, but the command line tools are
|
|
# then we can't run xcodebuild. On these systems we should
|
|
# default to clang
|
|
DEFAULT_TOOLCHAIN="clang"
|
|
fi
|
|
else
|
|
# First toolchain type in the list is the default
|
|
DEFAULT_TOOLCHAIN=${VALID_TOOLCHAINS%% *}
|
|
fi
|
|
|
|
if test "x$with_toolchain_type" = xlist; then
|
|
# List all toolchains
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchains are valid on this platform:" >&5
|
|
$as_echo "$as_me: The following toolchains are valid on this platform:" >&6;}
|
|
for toolchain in $VALID_TOOLCHAINS; do
|
|
toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
|
|
TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
|
|
$PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
|
|
done
|
|
|
|
exit 0
|
|
elif test "x$with_toolchain_type" != x; then
|
|
# User override; check that it is valid
|
|
if test "x${VALID_TOOLCHAINS/$with_toolchain_type/}" = "x${VALID_TOOLCHAINS}"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Toolchain type $with_toolchain_type is not valid on this platform." >&5
|
|
$as_echo "$as_me: Toolchain type $with_toolchain_type is not valid on this platform." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Valid toolchains: $VALID_TOOLCHAINS." >&5
|
|
$as_echo "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
|
|
as_fn_error $? "Cannot continue." "$LINENO" 5
|
|
fi
|
|
TOOLCHAIN_TYPE=$with_toolchain_type
|
|
else
|
|
# No flag given, use default
|
|
TOOLCHAIN_TYPE=$DEFAULT_TOOLCHAIN
|
|
fi
|
|
|
|
|
|
TOOLCHAIN_CC_BINARY_clang="clang"
|
|
TOOLCHAIN_CC_BINARY_gcc="gcc"
|
|
TOOLCHAIN_CC_BINARY_microsoft="cl"
|
|
TOOLCHAIN_CC_BINARY_solstudio="cc"
|
|
TOOLCHAIN_CC_BINARY_xlc="xlc_r"
|
|
|
|
TOOLCHAIN_CXX_BINARY_clang="clang++"
|
|
TOOLCHAIN_CXX_BINARY_gcc="g++"
|
|
TOOLCHAIN_CXX_BINARY_microsoft="cl"
|
|
TOOLCHAIN_CXX_BINARY_solstudio="CC"
|
|
TOOLCHAIN_CXX_BINARY_xlc="xlC_r"
|
|
|
|
# Use indirect variable referencing
|
|
toolchain_var_name=TOOLCHAIN_DESCRIPTION_$TOOLCHAIN_TYPE
|
|
TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
|
|
toolchain_var_name=TOOLCHAIN_MINIMUM_VERSION_$TOOLCHAIN_TYPE
|
|
TOOLCHAIN_MINIMUM_VERSION=${!toolchain_var_name}
|
|
toolchain_var_name=TOOLCHAIN_CC_BINARY_$TOOLCHAIN_TYPE
|
|
TOOLCHAIN_CC_BINARY=${!toolchain_var_name}
|
|
toolchain_var_name=TOOLCHAIN_CXX_BINARY_$TOOLCHAIN_TYPE
|
|
TOOLCHAIN_CXX_BINARY=${!toolchain_var_name}
|
|
|
|
|
|
# Define filename patterns
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
LIBRARY_PREFIX=
|
|
SHARED_LIBRARY_SUFFIX='.dll'
|
|
STATIC_LIBRARY_SUFFIX='.lib'
|
|
SHARED_LIBRARY='$1.dll'
|
|
STATIC_LIBRARY='$1.lib'
|
|
OBJ_SUFFIX='.obj'
|
|
EXE_SUFFIX='.exe'
|
|
else
|
|
LIBRARY_PREFIX=lib
|
|
SHARED_LIBRARY_SUFFIX='.so'
|
|
STATIC_LIBRARY_SUFFIX='.a'
|
|
SHARED_LIBRARY='lib$1.so'
|
|
STATIC_LIBRARY='lib$1.a'
|
|
OBJ_SUFFIX='.o'
|
|
EXE_SUFFIX=''
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# For full static builds, we're overloading the SHARED_LIBRARY
|
|
# variables in order to limit the amount of changes required.
|
|
# It would be better to remove SHARED and just use LIBRARY and
|
|
# LIBRARY_SUFFIX for libraries that can be built either
|
|
# shared or static and use STATIC_* for libraries that are
|
|
# always built statically.
|
|
if test "x$STATIC_BUILD" = xtrue; then
|
|
SHARED_LIBRARY='lib$1.a'
|
|
SHARED_LIBRARY_SUFFIX='.a'
|
|
else
|
|
SHARED_LIBRARY='lib$1.dylib'
|
|
SHARED_LIBRARY_SUFFIX='.dylib'
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = "x$DEFAULT_TOOLCHAIN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&5
|
|
$as_echo "$as_me: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
|
|
$as_echo "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
|
|
fi
|
|
|
|
|
|
# User supplied flags should be used when configure detects compilers
|
|
|
|
if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&2;}
|
|
fi
|
|
|
|
if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&2;}
|
|
fi
|
|
|
|
if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&2;}
|
|
fi
|
|
|
|
|
|
# Check whether --with-extra-cflags was given.
|
|
if test "${with_extra_cflags+set}" = set; then :
|
|
withval=$with_extra_cflags;
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-extra-cxxflags was given.
|
|
if test "${with_extra_cxxflags+set}" = set; then :
|
|
withval=$with_extra_cxxflags;
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-extra-ldflags was given.
|
|
if test "${with_extra_ldflags+set}" = set; then :
|
|
withval=$with_extra_ldflags;
|
|
fi
|
|
|
|
|
|
EXTRA_CFLAGS="$with_extra_cflags"
|
|
EXTRA_CXXFLAGS="$with_extra_cxxflags"
|
|
EXTRA_LDFLAGS="$with_extra_ldflags"
|
|
|
|
|
|
|
|
|
|
|
|
# The global CFLAGS and LDLAGS variables are used by configure tests and
|
|
# should include the extra parameters
|
|
CFLAGS="$EXTRA_CFLAGS"
|
|
CXXFLAGS="$EXTRA_CXXFLAGS"
|
|
LDFLAGS="$EXTRA_LDFLAGS"
|
|
CPPFLAGS=""
|
|
|
|
# The sysroot cflags are needed for configure to be able to run the compilers
|
|
|
|
if test "x$SYSROOT" != "x"; then
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
# Solaris Studio does not have a concept of sysroot. Instead we must
|
|
# make sure the default include and lib dirs are appended to each
|
|
# compile and link command line. Must also add -I-xbuiltin to enable
|
|
# inlining of system functions and intrinsics.
|
|
SYSROOT_CFLAGS="-I-xbuiltin -I$SYSROOT/usr/include"
|
|
SYSROOT_LDFLAGS="-L$SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
|
|
-L$SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
SYSROOT_CFLAGS="--sysroot=$SYSROOT"
|
|
SYSROOT_LDFLAGS="--sysroot=$SYSROOT"
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
SYSROOT_CFLAGS="-isysroot $SYSROOT"
|
|
SYSROOT_LDFLAGS="-isysroot $SYSROOT"
|
|
fi
|
|
# The global CFLAGS and LDFLAGS variables need these for configure to function
|
|
CFLAGS="$CFLAGS $SYSROOT_CFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $SYSROOT_CFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $SYSROOT_CFLAGS"
|
|
LDFLAGS="$LDFLAGS $SYSROOT_LDFLAGS"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# We also need -iframework<path>/System/Library/Frameworks
|
|
SYSROOT_CFLAGS="$SYSROOT_CFLAGS -iframework $SYSROOT/System/Library/Frameworks"
|
|
SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -iframework $SYSROOT/System/Library/Frameworks"
|
|
# These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
|
|
# set this here so it doesn't have to be peppered throughout the forest
|
|
SYSROOT_CFLAGS="$SYSROOT_CFLAGS -F $SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
|
|
SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -F $SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Then detect the actual binaries needed
|
|
|
|
# FIXME: Is this needed?
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
|
|
# Store the CFLAGS etc passed to the configure script.
|
|
ORG_CFLAGS="$CFLAGS"
|
|
ORG_CXXFLAGS="$CXXFLAGS"
|
|
|
|
# autoconf magic only relies on PATH, so update it if tools dir is specified
|
|
OLD_PATH="$PATH"
|
|
|
|
# On Windows, we need to detect the visual studio installation first.
|
|
# This will change the PATH, but we need to keep that new PATH even
|
|
# after toolchain detection is done, since the compiler (on x86) uses
|
|
# it for DLL resolution in runtime.
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows" \
|
|
&& test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then
|
|
|
|
# Store path to cygwin link.exe to help excluding it when searching for
|
|
# VS linker. This must be done before changing the PATH when looking for VS.
|
|
# Extract the first word of "link", so it can be a program name with args.
|
|
set dummy link; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CYGWIN_LINK+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CYGWIN_LINK in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CYGWIN_LINK="$CYGWIN_LINK" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CYGWIN_LINK="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CYGWIN_LINK=$ac_cv_path_CYGWIN_LINK
|
|
if test -n "$CYGWIN_LINK"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_LINK" >&5
|
|
$as_echo "$CYGWIN_LINK" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CYGWIN_LINK" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
|
|
$as_echo_n "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
|
|
"$CYGWIN_LINK" --version > /dev/null
|
|
if test $? -eq 0 ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
# This might be the VS linker. Don't exclude it later on.
|
|
CYGWIN_LINK=""
|
|
fi
|
|
fi
|
|
|
|
# First-hand choice is to locate and run the vsvars bat file.
|
|
|
|
|
|
# Check whether --with-toolchain-version was given.
|
|
if test "${with_toolchain_version+set}" = set; then :
|
|
withval=$with_toolchain_version;
|
|
fi
|
|
|
|
|
|
if test "x$with_toolchain_version" = xlist; then
|
|
# List all toolchains
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
|
|
$as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
|
|
for version in $VALID_VS_VERSIONS; do
|
|
eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
|
|
$PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION"
|
|
done
|
|
|
|
exit 0
|
|
elif test "x$DEVKIT_VS_VERSION" != x; then
|
|
VS_VERSION=$DEVKIT_VS_VERSION
|
|
TOOLCHAIN_VERSION=$VS_VERSION
|
|
eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
|
|
eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
|
|
eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
|
|
eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
VS_PATH="$TOOLCHAIN_PATH:$PATH"
|
|
|
|
# Convert DEVKIT_VS_INCLUDE into windows style VS_INCLUDE so that it
|
|
# can still be exported as INCLUDE for compiler invocations without
|
|
# SYSROOT_CFLAGS
|
|
OLDIFS="$IFS"
|
|
IFS=";"
|
|
for i in $DEVKIT_VS_INCLUDE; do
|
|
ipath=$i
|
|
|
|
unix_path="$ipath"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
ipath="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
ipath="$windows_path"
|
|
fi
|
|
|
|
VS_INCLUDE="$VS_INCLUDE;$ipath"
|
|
done
|
|
# Convert DEVKIT_VS_LIB into VS_LIB so that it can still be exported
|
|
# as LIB for compiler invocations without SYSROOT_LDFLAGS
|
|
for i in $DEVKIT_VS_LIB; do
|
|
libpath=$i
|
|
|
|
unix_path="$libpath"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
libpath="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
libpath="$windows_path"
|
|
fi
|
|
|
|
VS_LIB="$VS_LIB;$libpath"
|
|
done
|
|
IFS="$OLDIFS"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
|
|
$as_echo "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
|
|
|
|
elif test "x$with_toolchain_version" != x; then
|
|
# User override; check that it is valid
|
|
if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
|
|
$as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
|
|
$as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
|
|
as_fn_error $? "Cannot continue." "$LINENO" 5
|
|
fi
|
|
VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
|
|
else
|
|
# No flag given, use default
|
|
VS_VERSIONS_PROBE_LIST="$VALID_VS_VERSIONS"
|
|
fi
|
|
|
|
for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do
|
|
|
|
VS_VERSION="$VS_VERSION"
|
|
eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}"
|
|
eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}"
|
|
eval VS_INSTALL_DIR="\${VS_VS_INSTALLDIR_${VS_VERSION}}"
|
|
eval SDK_INSTALL_DIR="\${VS_SDK_INSTALLDIR_${VS_VERSION}}"
|
|
|
|
# When using --with-tools-dir, assume it points to the correct and default
|
|
# version of Visual Studio or that --with-toolchain-version was also set.
|
|
if test "x$with_tools_dir" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="$with_tools_dir/../.."
|
|
METHOD="--with-tools-dir"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="$with_tools_dir/../../.."
|
|
METHOD="--with-tools-dir"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
# Having specified an argument which is incorrect will produce an instant failure;
|
|
# we should not go on looking
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
|
|
$as_echo "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
|
|
$as_echo "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
|
|
$as_echo "$as_me: directory within the Visual Studio installation" >&6;}
|
|
as_fn_error $? "Cannot locate a valid Visual Studio installation" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
VS_ENV_CMD=""
|
|
VS_ENV_ARGS=""
|
|
|
|
if test "x$VS_COMNTOOLS" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="$VS_COMNTOOLS/../.."
|
|
METHOD="$VS_COMNTOOLS_VAR variable"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
if test "x$PROGRAMFILES" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="$PROGRAMFILES/$VS_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
# Work around the insanely named ProgramFiles(x86) env variable
|
|
PROGRAMFILES_X86="`env | $SED -n 's/^ProgramFiles(x86)=//p'`"
|
|
if test "x$PROGRAMFILES_X86" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="$PROGRAMFILES_X86/$VS_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="C:/Program Files/$VS_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
VS_BASE="C:/Program Files (x86)/$VS_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VCVARSFILE="vc/bin/vcvars32.bat"
|
|
else
|
|
VCVARSFILE="vc/bin/amd64/vcvars64.bat"
|
|
fi
|
|
|
|
|
|
windows_path="$VS_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
VS_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
VS_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$VS_BASE"; then
|
|
if test -f "$VS_BASE/$VCVARSFILE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$VS_BASE/$VCVARSFILE"
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100', 'v110' or 'v120' for VS 2010, 2012 or VS2013
|
|
eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: $VCVARSFILE is missing, this is probably Visual Studio Express. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$SDK_INSTALL_DIR" != x; then
|
|
if test "x$ProgramW6432" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
WIN_SDK_BASE="$ProgramW6432/$SDK_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
windows_path="$WIN_SDK_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
WIN_SDK_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
WIN_SDK_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$WIN_SDK_BASE"; then
|
|
# There have been cases of partial or broken SDK installations. A missing
|
|
# lib dir is not going to work.
|
|
if test ! -d "$WIN_SDK_BASE/lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
|
|
elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VS_ENV_ARGS="/x86"
|
|
else
|
|
VS_ENV_ARGS="/x64"
|
|
fi
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
|
|
# TODO: improve detection for other versions of SDK
|
|
eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
if test "x$PROGRAMW6432" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
WIN_SDK_BASE="$PROGRAMW6432/$SDK_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
windows_path="$WIN_SDK_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
WIN_SDK_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
WIN_SDK_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$WIN_SDK_BASE"; then
|
|
# There have been cases of partial or broken SDK installations. A missing
|
|
# lib dir is not going to work.
|
|
if test ! -d "$WIN_SDK_BASE/lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
|
|
elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VS_ENV_ARGS="/x86"
|
|
else
|
|
VS_ENV_ARGS="/x64"
|
|
fi
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
|
|
# TODO: improve detection for other versions of SDK
|
|
eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
if test "x$PROGRAMFILES" != x; then
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
WIN_SDK_BASE="$PROGRAMFILES/$SDK_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
windows_path="$WIN_SDK_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
WIN_SDK_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
WIN_SDK_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$WIN_SDK_BASE"; then
|
|
# There have been cases of partial or broken SDK installations. A missing
|
|
# lib dir is not going to work.
|
|
if test ! -d "$WIN_SDK_BASE/lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
|
|
elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VS_ENV_ARGS="/x86"
|
|
else
|
|
VS_ENV_ARGS="/x64"
|
|
fi
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
|
|
# TODO: improve detection for other versions of SDK
|
|
eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
WIN_SDK_BASE="C:/Program Files/$SDK_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
windows_path="$WIN_SDK_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
WIN_SDK_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
WIN_SDK_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$WIN_SDK_BASE"; then
|
|
# There have been cases of partial or broken SDK installations. A missing
|
|
# lib dir is not going to work.
|
|
if test ! -d "$WIN_SDK_BASE/lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
|
|
elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VS_ENV_ARGS="/x86"
|
|
else
|
|
VS_ENV_ARGS="/x64"
|
|
fi
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
|
|
# TODO: improve detection for other versions of SDK
|
|
eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
VS_VERSION="${VS_VERSION}"
|
|
WIN_SDK_BASE="C:/Program Files (x86)/$SDK_INSTALL_DIR"
|
|
METHOD="well-known name"
|
|
|
|
windows_path="$WIN_SDK_BASE"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
WIN_SDK_BASE="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
WIN_SDK_BASE="$unix_path"
|
|
fi
|
|
|
|
if test -d "$WIN_SDK_BASE"; then
|
|
# There have been cases of partial or broken SDK installations. A missing
|
|
# lib dir is not going to work.
|
|
if test ! -d "$WIN_SDK_BASE/lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
|
|
elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
VS_ENV_ARGS="/x86"
|
|
else
|
|
VS_ENV_ARGS="/x64"
|
|
fi
|
|
# PLATFORM_TOOLSET is used during the compilation of the freetype sources (see
|
|
# 'LIB_BUILD_FREETYPE' in libraries.m4) and must be 'Windows7.1SDK' for Windows7.1SDK
|
|
# TODO: improve detection for other versions of SDK
|
|
eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
|
|
$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
|
|
$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$VS_ENV_CMD" != x; then
|
|
TOOLCHAIN_VERSION=$VS_VERSION
|
|
eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
|
|
eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
|
|
eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
|
|
eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
|
|
# The rest of the variables are already evaled while probing
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
|
|
$as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
|
|
break
|
|
fi
|
|
done
|
|
|
|
|
|
# If we have a devkit, skip all of the below.
|
|
if test "x$DEVKIT_VS_VERSION" = x; then
|
|
if test "x$VS_ENV_CMD" != x; then
|
|
# We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$VS_ENV_CMD" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$VS_ENV_CMD"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$VS_ENV_CMD"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$VS_ENV_CMD"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
VS_ENV_CMD="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting VS_ENV_CMD to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting VS_ENV_CMD to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
# Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Trying to extract Visual Studio environment variables" >&5
|
|
$as_echo "$as_me: Trying to extract Visual Studio environment variables" >&6;}
|
|
|
|
# We need to create a couple of temporary files.
|
|
VS_ENV_TMP_DIR="$CONFIGURESUPPORT_OUTPUTDIR/vs-env"
|
|
$MKDIR -p $VS_ENV_TMP_DIR
|
|
|
|
# Cannot use the VS10 setup script directly (since it only updates the DOS subshell environment).
|
|
# Instead create a shell script which will set the relevant variables when run.
|
|
WINPATH_VS_ENV_CMD="$VS_ENV_CMD"
|
|
|
|
unix_path="$WINPATH_VS_ENV_CMD"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
WINPATH_VS_ENV_CMD="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
WINPATH_VS_ENV_CMD="$windows_path"
|
|
fi
|
|
|
|
WINPATH_BASH="$BASH"
|
|
|
|
unix_path="$WINPATH_BASH"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
WINPATH_BASH="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
WINPATH_BASH="$windows_path"
|
|
fi
|
|
|
|
|
|
# Generate a DOS batch file which runs $VS_ENV_CMD, and then creates a shell
|
|
# script (executable by bash) that will setup the important variables.
|
|
EXTRACT_VC_ENV_BAT_FILE="$VS_ENV_TMP_DIR/extract-vs-env.bat"
|
|
$ECHO "@echo off" > $EXTRACT_VC_ENV_BAT_FILE
|
|
# This will end up something like:
|
|
# call C:/progra~2/micros~2.0/vc/bin/amd64/vcvars64.bat
|
|
$ECHO "call $WINPATH_VS_ENV_CMD $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE
|
|
# These will end up something like:
|
|
# C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh
|
|
# The trailing space for everyone except PATH is no typo, but is needed due
|
|
# to trailing \ in the Windows paths. These will be stripped later.
|
|
$ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' \
|
|
>> $EXTRACT_VC_ENV_BAT_FILE
|
|
$ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE\;$include \" >> set-vs-env.sh' \
|
|
>> $EXTRACT_VC_ENV_BAT_FILE
|
|
$ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB\;$lib \" >> set-vs-env.sh' \
|
|
>> $EXTRACT_VC_ENV_BAT_FILE
|
|
$ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' \
|
|
>> $EXTRACT_VC_ENV_BAT_FILE
|
|
$ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' \
|
|
>> $EXTRACT_VC_ENV_BAT_FILE
|
|
$ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' \
|
|
>> $EXTRACT_VC_ENV_BAT_FILE
|
|
|
|
# Now execute the newly created bat file.
|
|
# The | cat is to stop SetEnv.Cmd to mess with system colors on msys.
|
|
# Change directory so we don't need to mess with Windows paths in redirects.
|
|
cd $VS_ENV_TMP_DIR
|
|
cmd /c extract-vs-env.bat | $CAT
|
|
cd $CURDIR
|
|
|
|
if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
|
|
$as_echo "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
|
|
$as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
|
|
$as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
|
|
as_fn_error $? "Cannot continue" "$LINENO" 5
|
|
fi
|
|
|
|
# Now set all paths and other env variables. This will allow the rest of
|
|
# the configure script to find and run the compiler in the proper way.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
|
|
$as_echo "$as_me: Setting extracted environment variables" >&6;}
|
|
. $VS_ENV_TMP_DIR/set-vs-env.sh
|
|
# Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
|
|
# also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
|
|
else
|
|
# We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
|
|
$as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
|
|
fi
|
|
fi
|
|
|
|
# At this point, we should have correct variables in the environment, or we can't continue.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
|
|
$as_echo_n "checking for Visual Studio variables... " >&6; }
|
|
|
|
if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \
|
|
|| test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then
|
|
if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
|
|
$as_echo "present but broken" >&6; }
|
|
as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
# Remove any trailing "\" ";" and " " from the variables.
|
|
VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED -e 's/\\\\*;* *$//'`
|
|
VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\*;* *$//'`
|
|
VCINSTALLDIR=`$ECHO "$VCINSTALLDIR" | $SED 's/\\\\* *$//'`
|
|
WindowsSDKDir=`$ECHO "$WindowsSDKDir" | $SED 's/\\\\* *$//'`
|
|
WINDOWSSDKDIR=`$ECHO "$WINDOWSSDKDIR" | $SED 's/\\\\* *$//'`
|
|
# Remove any paths containing # (typically F#) as that messes up make. This
|
|
# is needed if visual studio was installed with F# support.
|
|
VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[^:#]*#[^:]*://g'`
|
|
|
|
|
|
|
|
|
|
|
|
# Convert VS_INCLUDE into SYSROOT_CFLAGS
|
|
OLDIFS="$IFS"
|
|
IFS=";"
|
|
for i in $VS_INCLUDE; do
|
|
ipath=$i
|
|
# Only process non-empty elements
|
|
if test "x$ipath" != x; then
|
|
IFS="$OLDIFS"
|
|
# Check that directory exists before calling fixup_path
|
|
testpath=$ipath
|
|
|
|
windows_path="$testpath"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
testpath="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
testpath="$unix_path"
|
|
fi
|
|
|
|
if test -d "$testpath"; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$ipath" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$ipath"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of ipath, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of ipath, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of ipath" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
ipath="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ipath to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting ipath to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$ipath"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
ipath="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting ipath to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting ipath to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$ipath"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of ipath, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of ipath, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of ipath, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
ipath="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
ipath="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
SYSROOT_CFLAGS="$SYSROOT_CFLAGS -I$ipath"
|
|
fi
|
|
IFS=";"
|
|
fi
|
|
done
|
|
# Convert VS_LIB into SYSROOT_LDFLAGS
|
|
for i in $VS_LIB; do
|
|
libpath=$i
|
|
# Only process non-empty elements
|
|
if test "x$libpath" != x; then
|
|
IFS="$OLDIFS"
|
|
# Check that directory exists before calling fixup_path
|
|
testpath=$libpath
|
|
|
|
windows_path="$testpath"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
testpath="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
testpath="$unix_path"
|
|
fi
|
|
|
|
if test -d "$testpath"; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$libpath" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$libpath"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of libpath, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of libpath, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of libpath" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
libpath="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting libpath to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting libpath to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$libpath"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
libpath="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting libpath to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting libpath to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$libpath"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of libpath, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of libpath, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of libpath, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
libpath="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
libpath="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -libpath:$libpath"
|
|
fi
|
|
IFS=";"
|
|
fi
|
|
done
|
|
IFS="$OLDIFS"
|
|
fi
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
|
|
if test "x$VS_ENV_CMD" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&5
|
|
$as_echo "$as_me: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: nor is this script run from a Visual Studio command prompt." >&5
|
|
$as_echo "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
|
|
$as_echo "$as_me: Running the extraction script failed." >&6;}
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
|
|
$as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
|
|
$as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
|
|
as_fn_error $? "Cannot continue" "$LINENO" 5
|
|
fi
|
|
|
|
# Reset path to VS_PATH. It will include everything that was on PATH at the time we
|
|
# ran TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV.
|
|
PATH="$VS_PATH"
|
|
# The microsoft toolchain also requires INCLUDE and LIB to be set.
|
|
export INCLUDE="$VS_INCLUDE"
|
|
export LIB="$VS_LIB"
|
|
else
|
|
if test "x$XCODE_VERSION_OUTPUT" != x; then
|
|
# For Xcode, we set the Xcode version as TOOLCHAIN_VERSION
|
|
TOOLCHAIN_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | $CUT -f 2 -d ' '`
|
|
TOOLCHAIN_DESCRIPTION="$TOOLCHAIN_DESCRIPTION from Xcode"
|
|
else
|
|
# Currently we do not define this for other toolchains. This might change as the need arise.
|
|
TOOLCHAIN_VERSION=
|
|
fi
|
|
fi
|
|
|
|
|
|
# Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to
|
|
# override all other locations.
|
|
if test "x$TOOLCHAIN_PATH" != x; then
|
|
PATH=$TOOLCHAIN_PATH:$PATH
|
|
fi
|
|
|
|
|
|
#
|
|
# Setup the compilers (CC and CXX)
|
|
#
|
|
|
|
COMPILER_NAME=C
|
|
SEARCH_LIST="$TOOLCHAIN_CC_BINARY"
|
|
|
|
if test "x$CC" != x; then
|
|
# User has supplied compiler name already, always let that override.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CC=$CC" >&5
|
|
$as_echo "$as_me: Will use user supplied compiler CC=$CC" >&6;}
|
|
if test "x`basename $CC`" = "x$CC"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
|
|
for ac_prog in $CC
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_POTENTIAL_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $POTENTIAL_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
|
|
if test -n "$POTENTIAL_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
|
|
$as_echo "$POTENTIAL_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$POTENTIAL_CC" && break
|
|
done
|
|
|
|
if test "x$POTENTIAL_CC" != x; then
|
|
CC=$POTENTIAL_CC
|
|
else
|
|
as_fn_error $? "User supplied compiler CC=$CC could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise it might already be a complete path
|
|
if test ! -x "$CC"; then
|
|
as_fn_error $? "User supplied compiler CC=$CC does not exist" "$LINENO" 5
|
|
fi
|
|
fi
|
|
else
|
|
# No user supplied value. Locate compiler ourselves.
|
|
|
|
# If we are cross compiling, assume cross compilation tools follows the
|
|
# cross compilation standard where they are prefixed with the autoconf
|
|
# standard name for the target. For example the binary
|
|
# i686-sun-solaris2.10-gcc will cross compile for i686-sun-solaris2.10.
|
|
# If we are not cross compiling, then the default compiler name will be
|
|
# used.
|
|
|
|
CC=
|
|
# If TOOLCHAIN_PATH is set, check for all compiler names in there first
|
|
# before checking the rest of the PATH.
|
|
# FIXME: Now that we prefix the TOOLS_DIR to the PATH in the PRE_DETECTION
|
|
# step, this should not be necessary.
|
|
if test -n "$TOOLCHAIN_PATH"; then
|
|
PATH_save="$PATH"
|
|
PATH="$TOOLCHAIN_PATH"
|
|
if test -n "$ac_tool_prefix"; then
|
|
# Extract the first word of "${ac_tool_prefix}$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy ${ac_tool_prefix}$SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TOOLCHAIN_PATH_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TOOLCHAIN_PATH_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TOOLCHAIN_PATH_CC="$TOOLCHAIN_PATH_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TOOLCHAIN_PATH_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TOOLCHAIN_PATH_CC=$ac_cv_path_TOOLCHAIN_PATH_CC
|
|
if test -n "$TOOLCHAIN_PATH_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CC" >&5
|
|
$as_echo "$TOOLCHAIN_PATH_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
fi
|
|
if test -z "$ac_cv_path_TOOLCHAIN_PATH_CC"; then
|
|
ac_pt_TOOLCHAIN_PATH_CC=$TOOLCHAIN_PATH_CC
|
|
# Extract the first word of "$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy $SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ac_pt_TOOLCHAIN_PATH_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ac_pt_TOOLCHAIN_PATH_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ac_pt_TOOLCHAIN_PATH_CC="$ac_pt_TOOLCHAIN_PATH_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ac_pt_TOOLCHAIN_PATH_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ac_pt_TOOLCHAIN_PATH_CC=$ac_cv_path_ac_pt_TOOLCHAIN_PATH_CC
|
|
if test -n "$ac_pt_TOOLCHAIN_PATH_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_TOOLCHAIN_PATH_CC" >&5
|
|
$as_echo "$ac_pt_TOOLCHAIN_PATH_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
if test "x$ac_pt_TOOLCHAIN_PATH_CC" = x; then
|
|
TOOLCHAIN_PATH_CC=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
TOOLCHAIN_PATH_CC=$ac_pt_TOOLCHAIN_PATH_CC
|
|
fi
|
|
else
|
|
TOOLCHAIN_PATH_CC="$ac_cv_path_TOOLCHAIN_PATH_CC"
|
|
fi
|
|
|
|
CC=$TOOLCHAIN_PATH_CC
|
|
PATH="$PATH_save"
|
|
fi
|
|
|
|
# AC_PATH_TOOL can't be run multiple times with the same variable,
|
|
# so create a new name for this run.
|
|
if test "x$CC" = x; then
|
|
if test -n "$ac_tool_prefix"; then
|
|
# Extract the first word of "${ac_tool_prefix}$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy ${ac_tool_prefix}$SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_POTENTIAL_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $POTENTIAL_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
|
|
if test -n "$POTENTIAL_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
|
|
$as_echo "$POTENTIAL_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
fi
|
|
if test -z "$ac_cv_path_POTENTIAL_CC"; then
|
|
ac_pt_POTENTIAL_CC=$POTENTIAL_CC
|
|
# Extract the first word of "$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy $SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ac_pt_POTENTIAL_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ac_pt_POTENTIAL_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ac_pt_POTENTIAL_CC="$ac_pt_POTENTIAL_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ac_pt_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ac_pt_POTENTIAL_CC=$ac_cv_path_ac_pt_POTENTIAL_CC
|
|
if test -n "$ac_pt_POTENTIAL_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_POTENTIAL_CC" >&5
|
|
$as_echo "$ac_pt_POTENTIAL_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
if test "x$ac_pt_POTENTIAL_CC" = x; then
|
|
POTENTIAL_CC=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
POTENTIAL_CC=$ac_pt_POTENTIAL_CC
|
|
fi
|
|
else
|
|
POTENTIAL_CC="$ac_cv_path_POTENTIAL_CC"
|
|
fi
|
|
|
|
CC=$POTENTIAL_CC
|
|
fi
|
|
|
|
if test "x$CC" = x; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# devkit is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=devkit
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find a $COMPILER_NAME compiler. $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now we have a compiler binary in CC. Make sure it's okay.
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$CC" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of CC, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
CC="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CC to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting CC to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
TEST_COMPILER="$CC"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CC" >&5
|
|
$as_echo_n "checking resolved symbolic links for CC... " >&6; }
|
|
SYMLINK_ORIGINAL="$TEST_COMPILER"
|
|
|
|
if test "x$OPENJDK_BUILD_OS" != xwindows; then
|
|
# Follow a chain of symbolic links. Use readlink
|
|
# where it exists, else fall back to horribly
|
|
# complicated shell code.
|
|
if test "x$READLINK_TESTED" != yes; then
|
|
# On MacOSX there is a readlink tool with a different
|
|
# purpose than the GNU readlink tool. Check the found readlink.
|
|
ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
|
|
if test "x$ISGNU" = x; then
|
|
# A readlink that we do not know how to use.
|
|
# Are there other non-GNU readlinks out there?
|
|
READLINK_TESTED=yes
|
|
READLINK=
|
|
fi
|
|
fi
|
|
|
|
if test "x$READLINK" != x; then
|
|
SYMLINK_ORIGINAL=`$READLINK -f $SYMLINK_ORIGINAL`
|
|
else
|
|
# Save the current directory for restoring afterwards
|
|
STARTDIR=$PWD
|
|
COUNTER=0
|
|
sym_link_dir=`$DIRNAME $SYMLINK_ORIGINAL`
|
|
sym_link_file=`$BASENAME $SYMLINK_ORIGINAL`
|
|
cd $sym_link_dir
|
|
# Use -P flag to resolve symlinks in directories.
|
|
cd `$THEPWDCMD -P`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
# Resolve file symlinks
|
|
while test $COUNTER -lt 20; do
|
|
ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
|
|
if test "x$ISLINK" == x; then
|
|
# This is not a symbolic link! We are done!
|
|
break
|
|
fi
|
|
# Again resolve directory symlinks since the target of the just found
|
|
# link could be in a different directory
|
|
cd `$DIRNAME $ISLINK`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
sym_link_file=`$BASENAME $ISLINK`
|
|
let COUNTER=COUNTER+1
|
|
done
|
|
cd $STARTDIR
|
|
SYMLINK_ORIGINAL=$sym_link_dir/$sym_link_file
|
|
fi
|
|
fi
|
|
|
|
if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
|
|
$as_echo "no symlink" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
|
|
$as_echo "$SYMLINK_ORIGINAL" >&6; }
|
|
|
|
# We can't handle ccache by gcc wrappers, since we need to know if we're
|
|
# using ccache. Instead ccache usage must be controlled by a configure option.
|
|
COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
|
|
if test "x$COMPILER_BASENAME" = "xccache"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Please use --enable-ccache instead of providing a wrapped compiler." >&5
|
|
$as_echo "$as_me: Please use --enable-ccache instead of providing a wrapped compiler." >&6;}
|
|
as_fn_error $? "$TEST_COMPILER is a symbolic link to ccache. This is not supported." "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
COMPILER=$CC
|
|
COMPILER_NAME=$COMPILER_NAME
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
# cc -V output typically looks like
|
|
# cc: Sun C 5.12 Linux_i386 2011/11/16
|
|
# or
|
|
# cc: Studio 12.5 Sun C 5.14 SunOS_sparc 2016/05/31
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
|
|
# Check that this is likely to be the Solaris Studio cc.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.* Sun $COMPILER_NAME" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove usage instructions (if present), and
|
|
# collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *[Uu]sage:.*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
# xlc -qversion output typically looks like
|
|
# IBM XL C/C++ for AIX, V11.1 (5724-X13)
|
|
# Version: 11.01.0000.0015
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
|
|
# Check that this is likely to be the IBM XL C compiler.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# There is no specific version flag, but all output starts with a version string.
|
|
# First line typically looks something like:
|
|
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
|
|
# Check that this is likely to be Microsoft CL.EXE.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# gcc --version output typically looks like
|
|
# gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
|
|
# Copyright (C) 2013 Free Software Foundation, Inc.
|
|
# This is free software; see the source for copying conditions. There is NO
|
|
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be GCC.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove Copyright and legalese from version string, and
|
|
# collapse into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *Copyright .*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
# clang --version output typically looks like
|
|
# Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
|
|
# clang version 3.3 (tags/RELEASE_33/final)
|
|
# or
|
|
# Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
|
|
# Target: x86_64-pc-linux-gnu
|
|
# Thread model: posix
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be clang
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
|
|
else
|
|
as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
|
|
fi
|
|
# This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
|
|
CC_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
|
|
# This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
|
|
CC_VERSION_STRING="$COMPILER_VERSION_STRING"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
|
|
$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
|
|
|
|
|
|
# Now that we have resolved CC ourself, let autoconf have its go at it
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in $CC
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$CC"; then
|
|
ac_cv_prog_CC="$CC" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
CC=$ac_cv_prog_CC
|
|
if test -n "$CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
|
|
$as_echo "$CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CC" && break
|
|
done
|
|
fi
|
|
if test -z "$CC"; then
|
|
ac_ct_CC=$CC
|
|
for ac_prog in $CC
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_CC"; then
|
|
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_CC="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_CC=$ac_cv_prog_ac_ct_CC
|
|
if test -n "$ac_ct_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
|
|
$as_echo "$ac_ct_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_CC" && break
|
|
done
|
|
|
|
if test "x$ac_ct_CC" = x; then
|
|
CC=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
CC=$ac_ct_CC
|
|
fi
|
|
fi
|
|
|
|
|
|
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "no acceptable C compiler found in \$PATH
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
|
|
# Provide some information about the compiler.
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
|
|
set X $ac_compile
|
|
ac_compiler=$2
|
|
for ac_option in --version -v -V -qversion; do
|
|
{ { ac_try="$ac_compiler $ac_option >&5"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
sed '10a\
|
|
... rest of stderr output deleted ...
|
|
10q' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
fi
|
|
rm -f conftest.er1 conftest.err
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }
|
|
done
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
ac_clean_files_save=$ac_clean_files
|
|
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
|
|
# Try to create an executable without -o first, disregard a.out.
|
|
# It will help us diagnose broken compilers, and finding out an intuition
|
|
# of exeext.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
|
|
$as_echo_n "checking whether the C compiler works... " >&6; }
|
|
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
|
|
|
|
# The possible output files:
|
|
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
|
|
|
|
ac_rmfiles=
|
|
for ac_file in $ac_files
|
|
do
|
|
case $ac_file in
|
|
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
|
|
* ) ac_rmfiles="$ac_rmfiles $ac_file";;
|
|
esac
|
|
done
|
|
rm -f $ac_rmfiles
|
|
|
|
if { { ac_try="$ac_link_default"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_link_default") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then :
|
|
# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
|
|
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
|
|
# in a Makefile. We should not override ac_cv_exeext if it was cached,
|
|
# so that the user can short-circuit this test for compilers unknown to
|
|
# Autoconf.
|
|
for ac_file in $ac_files ''
|
|
do
|
|
test -f "$ac_file" || continue
|
|
case $ac_file in
|
|
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
|
|
;;
|
|
[ab].out )
|
|
# We found the default executable, but exeext='' is most
|
|
# certainly right.
|
|
break;;
|
|
*.* )
|
|
if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
|
|
then :; else
|
|
ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
|
|
fi
|
|
# We set ac_cv_exeext here because the later test for it is not
|
|
# safe: cross compilers may not add the suffix if given an `-o'
|
|
# argument, so we may need to know it at that point already.
|
|
# Even if this section looks crufty: it has the advantage of
|
|
# actually working.
|
|
break;;
|
|
* )
|
|
break;;
|
|
esac
|
|
done
|
|
test "$ac_cv_exeext" = no && ac_cv_exeext=
|
|
|
|
else
|
|
ac_file=''
|
|
fi
|
|
if test -z "$ac_file"; then :
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error 77 "C compiler cannot create executables
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
|
|
$as_echo_n "checking for C compiler default output file name... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
|
|
$as_echo "$ac_file" >&6; }
|
|
ac_exeext=$ac_cv_exeext
|
|
|
|
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
|
|
ac_clean_files=$ac_clean_files_save
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
|
|
$as_echo_n "checking for suffix of executables... " >&6; }
|
|
if { { ac_try="$ac_link"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_link") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then :
|
|
# If both `conftest.exe' and `conftest' are `present' (well, observable)
|
|
# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
|
|
# work properly (i.e., refer to `conftest.exe'), while it won't with
|
|
# `rm'.
|
|
for ac_file in conftest.exe conftest conftest.*; do
|
|
test -f "$ac_file" || continue
|
|
case $ac_file in
|
|
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
|
|
*.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
|
|
break;;
|
|
* ) break;;
|
|
esac
|
|
done
|
|
else
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
fi
|
|
rm -f conftest conftest$ac_cv_exeext
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
|
|
$as_echo "$ac_cv_exeext" >&6; }
|
|
|
|
rm -f conftest.$ac_ext
|
|
EXEEXT=$ac_cv_exeext
|
|
ac_exeext=$EXEEXT
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <stdio.h>
|
|
int
|
|
main ()
|
|
{
|
|
FILE *f = fopen ("conftest.out", "w");
|
|
return ferror (f) || fclose (f) != 0;
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
ac_clean_files="$ac_clean_files conftest.out"
|
|
# Check that the compiler produces executables we can run. If not, either
|
|
# the compiler is broken, or we cross compile.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
|
|
$as_echo_n "checking whether we are cross compiling... " >&6; }
|
|
if test "$cross_compiling" != yes; then
|
|
{ { ac_try="$ac_link"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_link") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }
|
|
if { ac_try='./conftest$ac_cv_exeext'
|
|
{ { case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_try") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; }; then
|
|
cross_compiling=no
|
|
else
|
|
if test "$cross_compiling" = maybe; then
|
|
cross_compiling=yes
|
|
else
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "cannot run C compiled programs.
|
|
If you meant to cross compile, use \`--host'.
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
fi
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
|
|
$as_echo "$cross_compiling" >&6; }
|
|
|
|
rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
|
|
ac_clean_files=$ac_clean_files_save
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
|
|
$as_echo_n "checking for suffix of object files... " >&6; }
|
|
if ${ac_cv_objext+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
rm -f conftest.o conftest.obj
|
|
if { { ac_try="$ac_compile"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_compile") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then :
|
|
for ac_file in conftest.o conftest.obj conftest.*; do
|
|
test -f "$ac_file" || continue;
|
|
case $ac_file in
|
|
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
|
|
*) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
|
|
break;;
|
|
esac
|
|
done
|
|
else
|
|
$as_echo "$as_me: failed program was:" >&5
|
|
sed 's/^/| /' conftest.$ac_ext >&5
|
|
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "cannot compute suffix of object files: cannot compile
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
fi
|
|
rm -f conftest.$ac_cv_objext conftest.$ac_ext
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
|
|
$as_echo "$ac_cv_objext" >&6; }
|
|
OBJEXT=$ac_cv_objext
|
|
ac_objext=$OBJEXT
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
|
|
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
|
|
if ${ac_cv_c_compiler_gnu+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
#ifndef __GNUC__
|
|
choke me
|
|
#endif
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
ac_compiler_gnu=yes
|
|
else
|
|
ac_compiler_gnu=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_cv_c_compiler_gnu=$ac_compiler_gnu
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
|
|
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
|
|
if test $ac_compiler_gnu = yes; then
|
|
GCC=yes
|
|
else
|
|
GCC=
|
|
fi
|
|
ac_test_CFLAGS=${CFLAGS+set}
|
|
ac_save_CFLAGS=$CFLAGS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
|
|
$as_echo_n "checking whether $CC accepts -g... " >&6; }
|
|
if ${ac_cv_prog_cc_g+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_save_c_werror_flag=$ac_c_werror_flag
|
|
ac_c_werror_flag=yes
|
|
ac_cv_prog_cc_g=no
|
|
CFLAGS="-g"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
ac_cv_prog_cc_g=yes
|
|
else
|
|
CFLAGS=""
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
ac_c_werror_flag=$ac_save_c_werror_flag
|
|
CFLAGS="-g"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
ac_cv_prog_cc_g=yes
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_c_werror_flag=$ac_save_c_werror_flag
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
|
|
$as_echo "$ac_cv_prog_cc_g" >&6; }
|
|
if test "$ac_test_CFLAGS" = set; then
|
|
CFLAGS=$ac_save_CFLAGS
|
|
elif test $ac_cv_prog_cc_g = yes; then
|
|
if test "$GCC" = yes; then
|
|
CFLAGS="-g -O2"
|
|
else
|
|
CFLAGS="-g"
|
|
fi
|
|
else
|
|
if test "$GCC" = yes; then
|
|
CFLAGS="-O2"
|
|
else
|
|
CFLAGS=
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
|
|
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
|
|
if ${ac_cv_prog_cc_c89+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_cv_prog_cc_c89=no
|
|
ac_save_CC=$CC
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
struct stat;
|
|
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
|
|
struct buf { int x; };
|
|
FILE * (*rcsopen) (struct buf *, struct stat *, int);
|
|
static char *e (p, i)
|
|
char **p;
|
|
int i;
|
|
{
|
|
return p[i];
|
|
}
|
|
static char *f (char * (*g) (char **, int), char **p, ...)
|
|
{
|
|
char *s;
|
|
va_list v;
|
|
va_start (v,p);
|
|
s = g (p, va_arg (v,int));
|
|
va_end (v);
|
|
return s;
|
|
}
|
|
|
|
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
|
|
function prototypes and stuff, but not '\xHH' hex character constants.
|
|
These don't provoke an error unfortunately, instead are silently treated
|
|
as 'x'. The following induces an error, until -std is added to get
|
|
proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
|
|
array size at least. It's necessary to write '\x00'==0 to get something
|
|
that's true only with -std. */
|
|
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
|
|
|
|
/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
|
|
inside strings and character constants. */
|
|
#define FOO(x) 'x'
|
|
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
|
|
|
|
int test (int i, double x);
|
|
struct s1 {int (*f) (int a);};
|
|
struct s2 {int (*f) (double a);};
|
|
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
|
|
int argc;
|
|
char **argv;
|
|
int
|
|
main ()
|
|
{
|
|
return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
|
|
-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
|
|
do
|
|
CC="$ac_save_CC $ac_arg"
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
ac_cv_prog_cc_c89=$ac_arg
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext
|
|
test "x$ac_cv_prog_cc_c89" != "xno" && break
|
|
done
|
|
rm -f conftest.$ac_ext
|
|
CC=$ac_save_CC
|
|
|
|
fi
|
|
# AC_CACHE_VAL
|
|
case "x$ac_cv_prog_cc_c89" in
|
|
x)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
|
|
$as_echo "none needed" >&6; } ;;
|
|
xno)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
|
|
$as_echo "unsupported" >&6; } ;;
|
|
*)
|
|
CC="$CC $ac_cv_prog_cc_c89"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
|
|
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
|
|
esac
|
|
if test "x$ac_cv_prog_cc_c89" != xno; then :
|
|
|
|
fi
|
|
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
|
|
|
|
COMPILER_NAME=C++
|
|
SEARCH_LIST="$TOOLCHAIN_CXX_BINARY"
|
|
|
|
if test "x$CXX" != x; then
|
|
# User has supplied compiler name already, always let that override.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CXX=$CXX" >&5
|
|
$as_echo "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
|
|
if test "x`basename $CXX`" = "x$CXX"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
|
|
for ac_prog in $CXX
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $POTENTIAL_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
|
|
if test -n "$POTENTIAL_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
|
|
$as_echo "$POTENTIAL_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$POTENTIAL_CXX" && break
|
|
done
|
|
|
|
if test "x$POTENTIAL_CXX" != x; then
|
|
CXX=$POTENTIAL_CXX
|
|
else
|
|
as_fn_error $? "User supplied compiler CXX=$CXX could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise it might already be a complete path
|
|
if test ! -x "$CXX"; then
|
|
as_fn_error $? "User supplied compiler CXX=$CXX does not exist" "$LINENO" 5
|
|
fi
|
|
fi
|
|
else
|
|
# No user supplied value. Locate compiler ourselves.
|
|
|
|
# If we are cross compiling, assume cross compilation tools follows the
|
|
# cross compilation standard where they are prefixed with the autoconf
|
|
# standard name for the target. For example the binary
|
|
# i686-sun-solaris2.10-gcc will cross compile for i686-sun-solaris2.10.
|
|
# If we are not cross compiling, then the default compiler name will be
|
|
# used.
|
|
|
|
CXX=
|
|
# If TOOLCHAIN_PATH is set, check for all compiler names in there first
|
|
# before checking the rest of the PATH.
|
|
# FIXME: Now that we prefix the TOOLS_DIR to the PATH in the PRE_DETECTION
|
|
# step, this should not be necessary.
|
|
if test -n "$TOOLCHAIN_PATH"; then
|
|
PATH_save="$PATH"
|
|
PATH="$TOOLCHAIN_PATH"
|
|
if test -n "$ac_tool_prefix"; then
|
|
# Extract the first word of "${ac_tool_prefix}$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy ${ac_tool_prefix}$SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_TOOLCHAIN_PATH_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $TOOLCHAIN_PATH_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_TOOLCHAIN_PATH_CXX="$TOOLCHAIN_PATH_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_TOOLCHAIN_PATH_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
TOOLCHAIN_PATH_CXX=$ac_cv_path_TOOLCHAIN_PATH_CXX
|
|
if test -n "$TOOLCHAIN_PATH_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CXX" >&5
|
|
$as_echo "$TOOLCHAIN_PATH_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
fi
|
|
if test -z "$ac_cv_path_TOOLCHAIN_PATH_CXX"; then
|
|
ac_pt_TOOLCHAIN_PATH_CXX=$TOOLCHAIN_PATH_CXX
|
|
# Extract the first word of "$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy $SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ac_pt_TOOLCHAIN_PATH_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ac_pt_TOOLCHAIN_PATH_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ac_pt_TOOLCHAIN_PATH_CXX="$ac_pt_TOOLCHAIN_PATH_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ac_pt_TOOLCHAIN_PATH_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ac_pt_TOOLCHAIN_PATH_CXX=$ac_cv_path_ac_pt_TOOLCHAIN_PATH_CXX
|
|
if test -n "$ac_pt_TOOLCHAIN_PATH_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_TOOLCHAIN_PATH_CXX" >&5
|
|
$as_echo "$ac_pt_TOOLCHAIN_PATH_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
if test "x$ac_pt_TOOLCHAIN_PATH_CXX" = x; then
|
|
TOOLCHAIN_PATH_CXX=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
TOOLCHAIN_PATH_CXX=$ac_pt_TOOLCHAIN_PATH_CXX
|
|
fi
|
|
else
|
|
TOOLCHAIN_PATH_CXX="$ac_cv_path_TOOLCHAIN_PATH_CXX"
|
|
fi
|
|
|
|
CXX=$TOOLCHAIN_PATH_CXX
|
|
PATH="$PATH_save"
|
|
fi
|
|
|
|
# AC_PATH_TOOL can't be run multiple times with the same variable,
|
|
# so create a new name for this run.
|
|
if test "x$CXX" = x; then
|
|
if test -n "$ac_tool_prefix"; then
|
|
# Extract the first word of "${ac_tool_prefix}$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy ${ac_tool_prefix}$SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $POTENTIAL_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
|
|
if test -n "$POTENTIAL_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
|
|
$as_echo "$POTENTIAL_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
fi
|
|
if test -z "$ac_cv_path_POTENTIAL_CXX"; then
|
|
ac_pt_POTENTIAL_CXX=$POTENTIAL_CXX
|
|
# Extract the first word of "$SEARCH_LIST", so it can be a program name with args.
|
|
set dummy $SEARCH_LIST; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ac_pt_POTENTIAL_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ac_pt_POTENTIAL_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ac_pt_POTENTIAL_CXX="$ac_pt_POTENTIAL_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ac_pt_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ac_pt_POTENTIAL_CXX=$ac_cv_path_ac_pt_POTENTIAL_CXX
|
|
if test -n "$ac_pt_POTENTIAL_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_POTENTIAL_CXX" >&5
|
|
$as_echo "$ac_pt_POTENTIAL_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
if test "x$ac_pt_POTENTIAL_CXX" = x; then
|
|
POTENTIAL_CXX=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
POTENTIAL_CXX=$ac_pt_POTENTIAL_CXX
|
|
fi
|
|
else
|
|
POTENTIAL_CXX="$ac_cv_path_POTENTIAL_CXX"
|
|
fi
|
|
|
|
CXX=$POTENTIAL_CXX
|
|
fi
|
|
|
|
if test "x$CXX" = x; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# devkit is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=devkit
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find a $COMPILER_NAME compiler. $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now we have a compiler binary in CXX. Make sure it's okay.
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$CXX" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CXX"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of CXX, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CXX"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CXX"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
CXX="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXX to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting CXX to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
TEST_COMPILER="$CXX"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CXX" >&5
|
|
$as_echo_n "checking resolved symbolic links for CXX... " >&6; }
|
|
SYMLINK_ORIGINAL="$TEST_COMPILER"
|
|
|
|
if test "x$OPENJDK_BUILD_OS" != xwindows; then
|
|
# Follow a chain of symbolic links. Use readlink
|
|
# where it exists, else fall back to horribly
|
|
# complicated shell code.
|
|
if test "x$READLINK_TESTED" != yes; then
|
|
# On MacOSX there is a readlink tool with a different
|
|
# purpose than the GNU readlink tool. Check the found readlink.
|
|
ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
|
|
if test "x$ISGNU" = x; then
|
|
# A readlink that we do not know how to use.
|
|
# Are there other non-GNU readlinks out there?
|
|
READLINK_TESTED=yes
|
|
READLINK=
|
|
fi
|
|
fi
|
|
|
|
if test "x$READLINK" != x; then
|
|
SYMLINK_ORIGINAL=`$READLINK -f $SYMLINK_ORIGINAL`
|
|
else
|
|
# Save the current directory for restoring afterwards
|
|
STARTDIR=$PWD
|
|
COUNTER=0
|
|
sym_link_dir=`$DIRNAME $SYMLINK_ORIGINAL`
|
|
sym_link_file=`$BASENAME $SYMLINK_ORIGINAL`
|
|
cd $sym_link_dir
|
|
# Use -P flag to resolve symlinks in directories.
|
|
cd `$THEPWDCMD -P`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
# Resolve file symlinks
|
|
while test $COUNTER -lt 20; do
|
|
ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
|
|
if test "x$ISLINK" == x; then
|
|
# This is not a symbolic link! We are done!
|
|
break
|
|
fi
|
|
# Again resolve directory symlinks since the target of the just found
|
|
# link could be in a different directory
|
|
cd `$DIRNAME $ISLINK`
|
|
sym_link_dir=`$THEPWDCMD -P`
|
|
sym_link_file=`$BASENAME $ISLINK`
|
|
let COUNTER=COUNTER+1
|
|
done
|
|
cd $STARTDIR
|
|
SYMLINK_ORIGINAL=$sym_link_dir/$sym_link_file
|
|
fi
|
|
fi
|
|
|
|
if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
|
|
$as_echo "no symlink" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
|
|
$as_echo "$SYMLINK_ORIGINAL" >&6; }
|
|
|
|
# We can't handle ccache by gcc wrappers, since we need to know if we're
|
|
# using ccache. Instead ccache usage must be controlled by a configure option.
|
|
COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
|
|
if test "x$COMPILER_BASENAME" = "xccache"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Please use --enable-ccache instead of providing a wrapped compiler." >&5
|
|
$as_echo "$as_me: Please use --enable-ccache instead of providing a wrapped compiler." >&6;}
|
|
as_fn_error $? "$TEST_COMPILER is a symbolic link to ccache. This is not supported." "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
COMPILER=$CXX
|
|
COMPILER_NAME=$COMPILER_NAME
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
# cc -V output typically looks like
|
|
# cc: Sun C 5.12 Linux_i386 2011/11/16
|
|
# or
|
|
# cc: Studio 12.5 Sun C 5.14 SunOS_sparc 2016/05/31
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
|
|
# Check that this is likely to be the Solaris Studio cc.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.* Sun $COMPILER_NAME" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove usage instructions (if present), and
|
|
# collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *[Uu]sage:.*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
# xlc -qversion output typically looks like
|
|
# IBM XL C/C++ for AIX, V11.1 (5724-X13)
|
|
# Version: 11.01.0000.0015
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
|
|
# Check that this is likely to be the IBM XL C compiler.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# There is no specific version flag, but all output starts with a version string.
|
|
# First line typically looks something like:
|
|
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
|
|
# Check that this is likely to be Microsoft CL.EXE.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# gcc --version output typically looks like
|
|
# gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
|
|
# Copyright (C) 2013 Free Software Foundation, Inc.
|
|
# This is free software; see the source for copying conditions. There is NO
|
|
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be GCC.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove Copyright and legalese from version string, and
|
|
# collapse into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *Copyright .*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
# clang --version output typically looks like
|
|
# Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
|
|
# clang version 3.3 (tags/RELEASE_33/final)
|
|
# or
|
|
# Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
|
|
# Target: x86_64-pc-linux-gnu
|
|
# Thread model: posix
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be clang
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
|
|
else
|
|
as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
|
|
fi
|
|
# This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
|
|
CXX_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
|
|
# This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
|
|
CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
|
|
$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
|
|
|
|
|
|
# Now that we have resolved CXX ourself, let autoconf have its go at it
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
if test -z "$CXX"; then
|
|
if test -n "$CCC"; then
|
|
CXX=$CCC
|
|
else
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in $CXX
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$CXX"; then
|
|
ac_cv_prog_CXX="$CXX" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
CXX=$ac_cv_prog_CXX
|
|
if test -n "$CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
|
|
$as_echo "$CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CXX" && break
|
|
done
|
|
fi
|
|
if test -z "$CXX"; then
|
|
ac_ct_CXX=$CXX
|
|
for ac_prog in $CXX
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_CXX"; then
|
|
ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_CXX="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
|
|
if test -n "$ac_ct_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
|
|
$as_echo "$ac_ct_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_CXX" && break
|
|
done
|
|
|
|
if test "x$ac_ct_CXX" = x; then
|
|
CXX="g++"
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
CXX=$ac_ct_CXX
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
# Provide some information about the compiler.
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
|
|
set X $ac_compile
|
|
ac_compiler=$2
|
|
for ac_option in --version -v -V -qversion; do
|
|
{ { ac_try="$ac_compiler $ac_option >&5"
|
|
case "(($ac_try" in
|
|
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
|
|
*) ac_try_echo=$ac_try;;
|
|
esac
|
|
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
|
|
$as_echo "$ac_try_echo"; } >&5
|
|
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
|
|
ac_status=$?
|
|
if test -s conftest.err; then
|
|
sed '10a\
|
|
... rest of stderr output deleted ...
|
|
10q' conftest.err >conftest.er1
|
|
cat conftest.er1 >&5
|
|
fi
|
|
rm -f conftest.er1 conftest.err
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }
|
|
done
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
|
|
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
|
|
if ${ac_cv_cxx_compiler_gnu+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
#ifndef __GNUC__
|
|
choke me
|
|
#endif
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_compiler_gnu=yes
|
|
else
|
|
ac_compiler_gnu=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
|
|
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
|
|
if test $ac_compiler_gnu = yes; then
|
|
GXX=yes
|
|
else
|
|
GXX=
|
|
fi
|
|
ac_test_CXXFLAGS=${CXXFLAGS+set}
|
|
ac_save_CXXFLAGS=$CXXFLAGS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
|
|
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
|
|
if ${ac_cv_prog_cxx_g+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_save_cxx_werror_flag=$ac_cxx_werror_flag
|
|
ac_cxx_werror_flag=yes
|
|
ac_cv_prog_cxx_g=no
|
|
CXXFLAGS="-g"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_cv_prog_cxx_g=yes
|
|
else
|
|
CXXFLAGS=""
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
ac_cxx_werror_flag=$ac_save_cxx_werror_flag
|
|
CXXFLAGS="-g"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_cv_prog_cxx_g=yes
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_cxx_werror_flag=$ac_save_cxx_werror_flag
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
|
|
$as_echo "$ac_cv_prog_cxx_g" >&6; }
|
|
if test "$ac_test_CXXFLAGS" = set; then
|
|
CXXFLAGS=$ac_save_CXXFLAGS
|
|
elif test $ac_cv_prog_cxx_g = yes; then
|
|
if test "$GXX" = yes; then
|
|
CXXFLAGS="-g -O2"
|
|
else
|
|
CXXFLAGS="-g"
|
|
fi
|
|
else
|
|
if test "$GXX" = yes; then
|
|
CXXFLAGS="-O2"
|
|
else
|
|
CXXFLAGS=
|
|
fi
|
|
fi
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
|
|
# This is the compiler version number on the form X.Y[.Z]
|
|
|
|
|
|
|
|
|
|
if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
|
|
$as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
|
|
$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
|
|
fi
|
|
|
|
# We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
|
|
if [[ "[$]CC_VERSION_NUMBER" =~ (.*\.){4} ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than four parts (W.X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
|
|
$as_echo "$as_me: WARNING: C compiler version number has more than four parts (W.X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
|
|
fi
|
|
|
|
if [[ "[$]CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
|
|
$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
|
|
fi
|
|
|
|
COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$CC_VERSION_NUMBER"`
|
|
|
|
|
|
if test "x$TOOLCHAIN_MINIMUM_VERSION" != x; then
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
# Need to assign to a variable since m4 is blocked from modifying parts in [].
|
|
REFERENCE_VERSION=$TOOLCHAIN_MINIMUM_VERSION
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ (.*\.){4} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to $TOOLCHAIN_MINIMUM_VERSION, only four parts (W.X.Y.Z) is supported" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to $TOOLCHAIN_MINIMUM_VERSION, only parts < 99999 is supported" "$LINENO" 5
|
|
fi
|
|
|
|
# Version comparison method inspired by http://stackoverflow.com/a/24067243
|
|
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$REFERENCE_VERSION"`
|
|
|
|
if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
|
|
:
|
|
|
|
else
|
|
:
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: You are using $TOOLCHAIN_TYPE older than $TOOLCHAIN_MINIMUM_VERSION. This is not a supported configuration." >&5
|
|
$as_echo "$as_me: WARNING: You are using $TOOLCHAIN_TYPE older than $TOOLCHAIN_MINIMUM_VERSION. This is not a supported configuration." >&2;}
|
|
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fi
|
|
|
|
#
|
|
# Setup the preprocessor (CPP and CXXCPP)
|
|
#
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
|
|
$as_echo_n "checking how to run the C preprocessor... " >&6; }
|
|
# On Suns, sometimes $CPP names a directory.
|
|
if test -n "$CPP" && test -d "$CPP"; then
|
|
CPP=
|
|
fi
|
|
if test -z "$CPP"; then
|
|
if ${ac_cv_prog_CPP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
# Double quotes because CPP needs to be expanded
|
|
for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
|
|
do
|
|
ac_preproc_ok=false
|
|
for ac_c_preproc_warn_flag in '' yes
|
|
do
|
|
# Use a header file that comes with gcc, so configuring glibc
|
|
# with a fresh cross-compiler works.
|
|
# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
|
|
# <limits.h> exists even on freestanding compilers.
|
|
# On the NeXT, cc -E runs the code through the compiler's parser,
|
|
# not just through cpp. "Syntax error" is here to catch this case.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#ifdef __STDC__
|
|
# include <limits.h>
|
|
#else
|
|
# include <assert.h>
|
|
#endif
|
|
Syntax error
|
|
_ACEOF
|
|
if ac_fn_c_try_cpp "$LINENO"; then :
|
|
|
|
else
|
|
# Broken: fails on valid input.
|
|
continue
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
# OK, works on sane cases. Now check whether nonexistent headers
|
|
# can be detected and how.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <ac_nonexistent.h>
|
|
_ACEOF
|
|
if ac_fn_c_try_cpp "$LINENO"; then :
|
|
# Broken: success on invalid input.
|
|
continue
|
|
else
|
|
# Passes both tests.
|
|
ac_preproc_ok=:
|
|
break
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
done
|
|
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
|
|
rm -f conftest.i conftest.err conftest.$ac_ext
|
|
if $ac_preproc_ok; then :
|
|
break
|
|
fi
|
|
|
|
done
|
|
ac_cv_prog_CPP=$CPP
|
|
|
|
fi
|
|
CPP=$ac_cv_prog_CPP
|
|
else
|
|
ac_cv_prog_CPP=$CPP
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
|
|
$as_echo "$CPP" >&6; }
|
|
ac_preproc_ok=false
|
|
for ac_c_preproc_warn_flag in '' yes
|
|
do
|
|
# Use a header file that comes with gcc, so configuring glibc
|
|
# with a fresh cross-compiler works.
|
|
# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
|
|
# <limits.h> exists even on freestanding compilers.
|
|
# On the NeXT, cc -E runs the code through the compiler's parser,
|
|
# not just through cpp. "Syntax error" is here to catch this case.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#ifdef __STDC__
|
|
# include <limits.h>
|
|
#else
|
|
# include <assert.h>
|
|
#endif
|
|
Syntax error
|
|
_ACEOF
|
|
if ac_fn_c_try_cpp "$LINENO"; then :
|
|
|
|
else
|
|
# Broken: fails on valid input.
|
|
continue
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
# OK, works on sane cases. Now check whether nonexistent headers
|
|
# can be detected and how.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <ac_nonexistent.h>
|
|
_ACEOF
|
|
if ac_fn_c_try_cpp "$LINENO"; then :
|
|
# Broken: success on invalid input.
|
|
continue
|
|
else
|
|
# Passes both tests.
|
|
ac_preproc_ok=:
|
|
break
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
done
|
|
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
|
|
rm -f conftest.i conftest.err conftest.$ac_ext
|
|
if $ac_preproc_ok; then :
|
|
|
|
else
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
fi
|
|
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$CPP" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CPP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of CPP, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CPP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CPP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
CPP="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CPP to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting CPP to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
|
|
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
|
|
if test -z "$CXXCPP"; then
|
|
if ${ac_cv_prog_CXXCPP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
# Double quotes because CXXCPP needs to be expanded
|
|
for CXXCPP in "$CXX -E" "/lib/cpp"
|
|
do
|
|
ac_preproc_ok=false
|
|
for ac_cxx_preproc_warn_flag in '' yes
|
|
do
|
|
# Use a header file that comes with gcc, so configuring glibc
|
|
# with a fresh cross-compiler works.
|
|
# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
|
|
# <limits.h> exists even on freestanding compilers.
|
|
# On the NeXT, cc -E runs the code through the compiler's parser,
|
|
# not just through cpp. "Syntax error" is here to catch this case.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#ifdef __STDC__
|
|
# include <limits.h>
|
|
#else
|
|
# include <assert.h>
|
|
#endif
|
|
Syntax error
|
|
_ACEOF
|
|
if ac_fn_cxx_try_cpp "$LINENO"; then :
|
|
|
|
else
|
|
# Broken: fails on valid input.
|
|
continue
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
# OK, works on sane cases. Now check whether nonexistent headers
|
|
# can be detected and how.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <ac_nonexistent.h>
|
|
_ACEOF
|
|
if ac_fn_cxx_try_cpp "$LINENO"; then :
|
|
# Broken: success on invalid input.
|
|
continue
|
|
else
|
|
# Passes both tests.
|
|
ac_preproc_ok=:
|
|
break
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
done
|
|
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
|
|
rm -f conftest.i conftest.err conftest.$ac_ext
|
|
if $ac_preproc_ok; then :
|
|
break
|
|
fi
|
|
|
|
done
|
|
ac_cv_prog_CXXCPP=$CXXCPP
|
|
|
|
fi
|
|
CXXCPP=$ac_cv_prog_CXXCPP
|
|
else
|
|
ac_cv_prog_CXXCPP=$CXXCPP
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
|
|
$as_echo "$CXXCPP" >&6; }
|
|
ac_preproc_ok=false
|
|
for ac_cxx_preproc_warn_flag in '' yes
|
|
do
|
|
# Use a header file that comes with gcc, so configuring glibc
|
|
# with a fresh cross-compiler works.
|
|
# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
|
|
# <limits.h> exists even on freestanding compilers.
|
|
# On the NeXT, cc -E runs the code through the compiler's parser,
|
|
# not just through cpp. "Syntax error" is here to catch this case.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#ifdef __STDC__
|
|
# include <limits.h>
|
|
#else
|
|
# include <assert.h>
|
|
#endif
|
|
Syntax error
|
|
_ACEOF
|
|
if ac_fn_cxx_try_cpp "$LINENO"; then :
|
|
|
|
else
|
|
# Broken: fails on valid input.
|
|
continue
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
# OK, works on sane cases. Now check whether nonexistent headers
|
|
# can be detected and how.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <ac_nonexistent.h>
|
|
_ACEOF
|
|
if ac_fn_cxx_try_cpp "$LINENO"; then :
|
|
# Broken: success on invalid input.
|
|
continue
|
|
else
|
|
# Passes both tests.
|
|
ac_preproc_ok=:
|
|
break
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
|
|
done
|
|
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
|
|
rm -f conftest.i conftest.err conftest.$ac_ext
|
|
if $ac_preproc_ok; then :
|
|
|
|
else
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
fi
|
|
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$CXXCPP" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CXXCPP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CXXCPP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$CXXCPP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
CXXCPP="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXXCPP to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
#
|
|
# Setup the linker (LD)
|
|
#
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# In the Microsoft toolchain we have a separate LD command "link".
|
|
# Make sure we reject /usr/bin/link (as determined in CYGWIN_LINK), which is
|
|
# a cygwin program for something completely different.
|
|
# Extract the first word of "link", so it can be a program name with args.
|
|
set dummy link; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_LD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$LD"; then
|
|
ac_cv_prog_LD="$LD" # Let the user override the test.
|
|
else
|
|
ac_prog_rejected=no
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
if test "$as_dir/$ac_word$ac_exec_ext" = "$CYGWIN_LINK"; then
|
|
ac_prog_rejected=yes
|
|
continue
|
|
fi
|
|
ac_cv_prog_LD="link"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
if test $ac_prog_rejected = yes; then
|
|
# We found a bogon in the path, so make sure we never use it.
|
|
set dummy $ac_cv_prog_LD
|
|
shift
|
|
if test $# != 0; then
|
|
# We chose a different compiler from the bogus one.
|
|
# However, it has the same basename, so the bogon will be chosen
|
|
# first if we set LD to just the basename; use the full file name.
|
|
shift
|
|
ac_cv_prog_LD="$as_dir/$ac_word${1+' '}$@"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
LD=$ac_cv_prog_LD
|
|
if test -n "$LD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
|
|
$as_echo "$LD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$LD" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$LD"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of LD, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$LD"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$LD"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
LD="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LD to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting LD to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
# Verify that we indeed succeeded with this trick.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the found link.exe is actually the Visual Studio linker" >&5
|
|
$as_echo_n "checking if the found link.exe is actually the Visual Studio linker... " >&6; }
|
|
"$LD" --version > /dev/null
|
|
if test $? -eq 0 ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
as_fn_error $? "This is the Cygwin link tool. Please check your PATH and rerun configure." "$LINENO" 5
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
LDCXX="$LD"
|
|
else
|
|
# All other toolchains use the compiler to link.
|
|
LD="$CC"
|
|
LDCXX="$CXX"
|
|
fi
|
|
|
|
# FIXME: it should be CXXLD, according to standard (cf CXXCPP)
|
|
|
|
|
|
#
|
|
# Setup the assembler (AS)
|
|
#
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${AS+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in as
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_AS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $AS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_AS="$AS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
AS=$ac_cv_path_AS
|
|
if test -n "$AS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
|
|
$as_echo "$AS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AS" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !AS! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AS!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xAS" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in as
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_AS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $AS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_AS="$AS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
AS=$ac_cv_path_AS
|
|
if test -n "$AS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
|
|
$as_echo "$AS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AS" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$AS" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AS= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool AS= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
|
|
$as_echo_n "checking for AS... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$AS"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_AS+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $AS in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_AS="$AS" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
AS=$ac_cv_path_AS
|
|
if test -n "$AS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
|
|
$as_echo "$AS" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$AS" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
|
|
$as_echo_n "checking for AS... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool AS=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$AS" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$AS"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of AS, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$AS"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$AS"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
AS="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$AS" = x; then
|
|
as_fn_error $? "Solaris assembler (as) is required. Please install via \"pkg install pkg:/developer/assembler\"." "$LINENO" 5
|
|
fi
|
|
else
|
|
# FIXME: is this correct for microsoft?
|
|
AS="$CC -c"
|
|
fi
|
|
|
|
|
|
#
|
|
# Setup the archiver (AR)
|
|
#
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# The corresponding ar tool is lib.exe (used to create static libraries)
|
|
# Extract the first word of "lib", so it can be a program name with args.
|
|
set dummy lib; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AR"; then
|
|
ac_cv_prog_AR="$AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AR="lib"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AR=$ac_cv_prog_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${AR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in ar gcc-ar
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AR"; then
|
|
ac_cv_prog_AR="$AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AR=$ac_cv_prog_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AR" && break
|
|
done
|
|
fi
|
|
if test -z "$AR"; then
|
|
ac_ct_AR=$AR
|
|
for ac_prog in ar gcc-ar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_AR"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_AR=$ac_cv_prog_ac_ct_AR
|
|
if test -n "$ac_ct_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
|
|
$as_echo "$ac_ct_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_AR" && break
|
|
done
|
|
|
|
if test "x$ac_ct_AR" = x; then
|
|
AR=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
AR=$ac_ct_AR
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !AR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xAR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in ar gcc-ar
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AR"; then
|
|
ac_cv_prog_AR="$AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AR=$ac_cv_prog_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AR" && break
|
|
done
|
|
fi
|
|
if test -z "$AR"; then
|
|
ac_ct_AR=$AR
|
|
for ac_prog in ar gcc-ar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_AR"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_AR=$ac_cv_prog_ac_ct_AR
|
|
if test -n "$ac_ct_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
|
|
$as_echo "$ac_ct_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_AR" && break
|
|
done
|
|
|
|
if test "x$ac_ct_AR" = x; then
|
|
AR=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
AR=$ac_ct_AR
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$AR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool AR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
|
|
$as_echo_n "checking for AR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$AR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $AR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_AR="$AR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
AR=$ac_cv_path_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$AR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
|
|
$as_echo_n "checking for AR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
else
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${AR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in ar
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AR"; then
|
|
ac_cv_prog_AR="$AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AR=$ac_cv_prog_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AR" && break
|
|
done
|
|
fi
|
|
if test -z "$AR"; then
|
|
ac_ct_AR=$AR
|
|
for ac_prog in ar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_AR"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_AR=$ac_cv_prog_ac_ct_AR
|
|
if test -n "$ac_ct_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
|
|
$as_echo "$ac_ct_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_AR" && break
|
|
done
|
|
|
|
if test "x$ac_ct_AR" = x; then
|
|
AR=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
AR=$ac_ct_AR
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !AR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xAR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in ar
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$AR"; then
|
|
ac_cv_prog_AR="$AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
AR=$ac_cv_prog_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$AR" && break
|
|
done
|
|
fi
|
|
if test -z "$AR"; then
|
|
ac_ct_AR=$AR
|
|
for ac_prog in ar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_AR"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_AR="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_AR=$ac_cv_prog_ac_ct_AR
|
|
if test -n "$ac_ct_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
|
|
$as_echo "$ac_ct_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_AR" && break
|
|
done
|
|
|
|
if test "x$ac_ct_AR" = x; then
|
|
AR=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
AR=$ac_ct_AR
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$AR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool AR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool AR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
|
|
$as_echo_n "checking for AR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$AR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $AR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_AR="$AR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
AR=$ac_cv_path_AR
|
|
if test -n "$AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
|
|
$as_echo "$AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$AR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
|
|
$as_echo_n "checking for AR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$AR" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$AR"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of AR, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$AR"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$AR"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
AR="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AR to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting AR to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${LIPO+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in lipo
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LIPO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LIPO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LIPO=$ac_cv_path_LIPO
|
|
if test -n "$LIPO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
|
|
$as_echo "$LIPO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LIPO" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !LIPO! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LIPO!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xLIPO" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in lipo
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LIPO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LIPO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LIPO=$ac_cv_path_LIPO
|
|
if test -n "$LIPO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
|
|
$as_echo "$LIPO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$LIPO" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$LIPO" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool LIPO= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool LIPO= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
|
|
$as_echo_n "checking for LIPO... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$LIPO"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LIPO=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool LIPO=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_LIPO+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $LIPO in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
LIPO=$ac_cv_path_LIPO
|
|
if test -n "$LIPO"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
|
|
$as_echo "$LIPO" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$LIPO" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LIPO=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool LIPO=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
|
|
$as_echo_n "checking for LIPO... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool LIPO=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$LIPO" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$LIPO"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of LIPO, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$LIPO"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$LIPO"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
LIPO="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LIPO to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# Extract the first word of "mt", so it can be a program name with args.
|
|
set dummy mt; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_MT+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$MT"; then
|
|
ac_cv_prog_MT="$MT" # Let the user override the test.
|
|
else
|
|
ac_prog_rejected=no
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/mt"; then
|
|
ac_prog_rejected=yes
|
|
continue
|
|
fi
|
|
ac_cv_prog_MT="mt"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
if test $ac_prog_rejected = yes; then
|
|
# We found a bogon in the path, so make sure we never use it.
|
|
set dummy $ac_cv_prog_MT
|
|
shift
|
|
if test $# != 0; then
|
|
# We chose a different compiler from the bogus one.
|
|
# However, it has the same basename, so the bogon will be chosen
|
|
# first if we set MT to just the basename; use the full file name.
|
|
shift
|
|
ac_cv_prog_MT="$as_dir/$ac_word${1+' '}$@"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
MT=$ac_cv_prog_MT
|
|
if test -n "$MT"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MT" >&5
|
|
$as_echo "$MT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MT" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$MT"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MT, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$MT"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$MT"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
MT="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MT to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting MT to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
# Setup the resource compiler (RC)
|
|
# Extract the first word of "rc", so it can be a program name with args.
|
|
set dummy rc; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_RC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$RC"; then
|
|
ac_cv_prog_RC="$RC" # Let the user override the test.
|
|
else
|
|
ac_prog_rejected=no
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/rc"; then
|
|
ac_prog_rejected=yes
|
|
continue
|
|
fi
|
|
ac_cv_prog_RC="rc"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
if test $ac_prog_rejected = yes; then
|
|
# We found a bogon in the path, so make sure we never use it.
|
|
set dummy $ac_cv_prog_RC
|
|
shift
|
|
if test $# != 0; then
|
|
# We chose a different compiler from the bogus one.
|
|
# However, it has the same basename, so the bogon will be chosen
|
|
# first if we set RC to just the basename; use the full file name.
|
|
shift
|
|
ac_cv_prog_RC="$as_dir/$ac_word${1+' '}$@"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
RC=$ac_cv_prog_RC
|
|
if test -n "$RC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
|
|
$as_echo "$RC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$RC" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$RC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of RC, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$RC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$RC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
RC="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting RC to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting RC to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
# Extract the first word of "dumpbin", so it can be a program name with args.
|
|
set dummy dumpbin; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_DUMPBIN+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$DUMPBIN"; then
|
|
ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_DUMPBIN="dumpbin"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
DUMPBIN=$ac_cv_prog_DUMPBIN
|
|
if test -n "$DUMPBIN"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
|
|
$as_echo "$DUMPBIN" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$DUMPBIN" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$DUMPBIN"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$DUMPBIN"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$DUMPBIN"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
DUMPBIN="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
# We need to check for 'msbuild.exe' because at the place where we expect to
|
|
# find 'msbuild.exe' there's also a directory called 'msbuild' and configure
|
|
# won't find the 'msbuild.exe' executable in that case (and the
|
|
# 'ac_executable_extensions' is unusable due to performance reasons).
|
|
# Notice that we intentionally don't fix up the path to MSBUILD because we
|
|
# will call it in a DOS shell during freetype detection on Windows (see
|
|
# 'LIB_SETUP_FREETYPE' in "libraries.m4"
|
|
# Extract the first word of "msbuild.exe", so it can be a program name with args.
|
|
set dummy msbuild.exe; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_MSBUILD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$MSBUILD"; then
|
|
ac_cv_prog_MSBUILD="$MSBUILD" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_MSBUILD="msbuild.exe"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
MSBUILD=$ac_cv_prog_MSBUILD
|
|
if test -n "$MSBUILD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSBUILD" >&5
|
|
$as_echo "$MSBUILD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${STRIP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STRIP=$ac_cv_path_STRIP
|
|
if test -n "$STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
|
|
$as_echo "$STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$STRIP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !STRIP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STRIP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSTRIP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STRIP=$ac_cv_path_STRIP
|
|
if test -n "$STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
|
|
$as_echo "$STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$STRIP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$STRIP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STRIP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool STRIP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
|
|
$as_echo_n "checking for STRIP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$STRIP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STRIP=$ac_cv_path_STRIP
|
|
if test -n "$STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
|
|
$as_echo "$STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$STRIP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
|
|
$as_echo_n "checking for STRIP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$STRIP" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
STRIP="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${NM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NM="$NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NM=$ac_cv_path_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NM" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !NM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xNM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NM="$NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NM=$ac_cv_path_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NM" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$NM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool NM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
|
|
$as_echo_n "checking for NM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$NM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NM="$NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NM=$ac_cv_path_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$NM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
|
|
$as_echo_n "checking for NM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$NM" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
NM="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${GNM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in gnm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GNM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GNM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GNM=$ac_cv_path_GNM
|
|
if test -n "$GNM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
|
|
$as_echo "$GNM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$GNM" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !GNM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GNM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xGNM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in gnm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GNM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GNM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GNM=$ac_cv_path_GNM
|
|
if test -n "$GNM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
|
|
$as_echo "$GNM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$GNM" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$GNM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool GNM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool GNM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
|
|
$as_echo_n "checking for GNM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$GNM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_GNM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $GNM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
GNM=$ac_cv_path_GNM
|
|
if test -n "$GNM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
|
|
$as_echo "$GNM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$GNM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
|
|
$as_echo_n "checking for GNM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool GNM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$GNM" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$GNM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of GNM, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$GNM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$GNM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
GNM="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
elif test "x$OPENJDK_TARGET_OS" != xwindows; then
|
|
# FIXME: we should unify this with the solaris case above.
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${STRIP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$STRIP"; then
|
|
ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
STRIP=$ac_cv_prog_STRIP
|
|
if test -n "$STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
|
|
$as_echo "$STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$STRIP" && break
|
|
done
|
|
fi
|
|
if test -z "$STRIP"; then
|
|
ac_ct_STRIP=$STRIP
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_STRIP"; then
|
|
ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_STRIP="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
|
|
if test -n "$ac_ct_STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
|
|
$as_echo "$ac_ct_STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_STRIP" && break
|
|
done
|
|
|
|
if test "x$ac_ct_STRIP" = x; then
|
|
STRIP=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
STRIP=$ac_ct_STRIP
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !STRIP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STRIP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xSTRIP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$STRIP"; then
|
|
ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
STRIP=$ac_cv_prog_STRIP
|
|
if test -n "$STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
|
|
$as_echo "$STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$STRIP" && break
|
|
done
|
|
fi
|
|
if test -z "$STRIP"; then
|
|
ac_ct_STRIP=$STRIP
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_STRIP"; then
|
|
ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_STRIP="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
|
|
if test -n "$ac_ct_STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
|
|
$as_echo "$ac_ct_STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_STRIP" && break
|
|
done
|
|
|
|
if test "x$ac_ct_STRIP" = x; then
|
|
STRIP=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
STRIP=$ac_ct_STRIP
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$STRIP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool STRIP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool STRIP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
|
|
$as_echo_n "checking for STRIP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$STRIP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
STRIP=$ac_cv_path_STRIP
|
|
if test -n "$STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
|
|
$as_echo "$STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$STRIP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
|
|
$as_echo_n "checking for STRIP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$STRIP" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
STRIP="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${NM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in nm gcc-nm
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$NM"; then
|
|
ac_cv_prog_NM="$NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
NM=$ac_cv_prog_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NM" && break
|
|
done
|
|
fi
|
|
if test -z "$NM"; then
|
|
ac_ct_NM=$NM
|
|
for ac_prog in nm gcc-nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_NM"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_NM=$ac_cv_prog_ac_ct_NM
|
|
if test -n "$ac_ct_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
|
|
$as_echo "$ac_ct_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_NM" && break
|
|
done
|
|
|
|
if test "x$ac_ct_NM" = x; then
|
|
NM=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
NM=$ac_ct_NM
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !NM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xNM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in nm gcc-nm
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$NM"; then
|
|
ac_cv_prog_NM="$NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
NM=$ac_cv_prog_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NM" && break
|
|
done
|
|
fi
|
|
if test -z "$NM"; then
|
|
ac_ct_NM=$NM
|
|
for ac_prog in nm gcc-nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_NM"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_NM=$ac_cv_prog_ac_ct_NM
|
|
if test -n "$ac_ct_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
|
|
$as_echo "$ac_ct_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_NM" && break
|
|
done
|
|
|
|
if test "x$ac_ct_NM" = x; then
|
|
NM=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
NM=$ac_ct_NM
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$NM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool NM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
|
|
$as_echo_n "checking for NM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$NM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NM="$NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NM=$ac_cv_path_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$NM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
|
|
$as_echo_n "checking for NM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
else
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${NM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in nm
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$NM"; then
|
|
ac_cv_prog_NM="$NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
NM=$ac_cv_prog_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NM" && break
|
|
done
|
|
fi
|
|
if test -z "$NM"; then
|
|
ac_ct_NM=$NM
|
|
for ac_prog in nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_NM"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_NM=$ac_cv_prog_ac_ct_NM
|
|
if test -n "$ac_ct_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
|
|
$as_echo "$ac_ct_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_NM" && break
|
|
done
|
|
|
|
if test "x$ac_ct_NM" = x; then
|
|
NM=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
NM=$ac_ct_NM
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !NM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xNM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in nm
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$NM"; then
|
|
ac_cv_prog_NM="$NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
NM=$ac_cv_prog_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$NM" && break
|
|
done
|
|
fi
|
|
if test -z "$NM"; then
|
|
ac_ct_NM=$NM
|
|
for ac_prog in nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_NM"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_NM="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_NM=$ac_cv_prog_ac_ct_NM
|
|
if test -n "$ac_ct_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
|
|
$as_echo "$ac_ct_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_NM" && break
|
|
done
|
|
|
|
if test "x$ac_ct_NM" = x; then
|
|
NM=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
NM=$ac_ct_NM
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$NM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool NM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool NM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
|
|
$as_echo_n "checking for NM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$NM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_NM="$NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
NM=$ac_cv_path_NM
|
|
if test -n "$NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
|
|
$as_echo "$NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$NM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
|
|
$as_echo_n "checking for NM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$NM" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
NM="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
GNM="$NM"
|
|
|
|
fi
|
|
|
|
# objcopy is used for moving debug symbols to separate files when
|
|
# full debug symbols are enabled.
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${OBJCOPY+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in gobjcopy objcopy
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$OBJCOPY"; then
|
|
ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
OBJCOPY=$ac_cv_prog_OBJCOPY
|
|
if test -n "$OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
|
|
$as_echo "$OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$OBJCOPY" && break
|
|
done
|
|
fi
|
|
if test -z "$OBJCOPY"; then
|
|
ac_ct_OBJCOPY=$OBJCOPY
|
|
for ac_prog in gobjcopy objcopy
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_OBJCOPY"; then
|
|
ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
|
|
if test -n "$ac_ct_OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
|
|
$as_echo "$ac_ct_OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_OBJCOPY" && break
|
|
done
|
|
|
|
if test "x$ac_ct_OBJCOPY" = x; then
|
|
OBJCOPY=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
OBJCOPY=$ac_ct_OBJCOPY
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !OBJCOPY! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OBJCOPY!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xOBJCOPY" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in gobjcopy objcopy
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$OBJCOPY"; then
|
|
ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
OBJCOPY=$ac_cv_prog_OBJCOPY
|
|
if test -n "$OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
|
|
$as_echo "$OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$OBJCOPY" && break
|
|
done
|
|
fi
|
|
if test -z "$OBJCOPY"; then
|
|
ac_ct_OBJCOPY=$OBJCOPY
|
|
for ac_prog in gobjcopy objcopy
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_OBJCOPY"; then
|
|
ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
|
|
if test -n "$ac_ct_OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
|
|
$as_echo "$ac_ct_OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_OBJCOPY" && break
|
|
done
|
|
|
|
if test "x$ac_ct_OBJCOPY" = x; then
|
|
OBJCOPY=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
OBJCOPY=$ac_ct_OBJCOPY
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$OBJCOPY" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OBJCOPY= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool OBJCOPY= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
|
|
$as_echo_n "checking for OBJCOPY... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$OBJCOPY"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $OBJCOPY in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
OBJCOPY=$ac_cv_path_OBJCOPY
|
|
if test -n "$OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
|
|
$as_echo "$OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$OBJCOPY" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
|
|
$as_echo_n "checking for OBJCOPY... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# Only call fixup if objcopy was found.
|
|
if test -n "$OBJCOPY"; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$OBJCOPY" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$OBJCOPY"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$OBJCOPY"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$OBJCOPY"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
OBJCOPY="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
# objcopy prior to 2.21.1 on solaris is broken and is not usable.
|
|
# Rewrite objcopy version output to VALID_VERSION or BAD_VERSION.
|
|
# - version number is last blank separate word on first line
|
|
# - version number formats that have been seen:
|
|
# - <major>.<minor>
|
|
# - <major>.<minor>.<micro>
|
|
OBJCOPY_VERSION=`$OBJCOPY --version | $HEAD -n 1`
|
|
# The outer [ ] is to prevent m4 from eating the [] in the sed expression.
|
|
OBJCOPY_VERSION_CHECK=`$ECHO $OBJCOPY_VERSION | $SED -n \
|
|
-e 's/.* //' \
|
|
-e '/^[01]\./b bad' \
|
|
-e '/^2\./{' \
|
|
-e ' s/^2\.//' \
|
|
-e ' /^[0-9]$/b bad' \
|
|
-e ' /^[0-9]\./b bad' \
|
|
-e ' /^1[0-9]$/b bad' \
|
|
-e ' /^1[0-9]\./b bad' \
|
|
-e ' /^20\./b bad' \
|
|
-e ' /^21\.0$/b bad' \
|
|
-e ' /^21\.0\./b bad' \
|
|
-e '}' \
|
|
-e ':good' \
|
|
-e 's/.*/VALID_VERSION/p' \
|
|
-e 'q' \
|
|
-e ':bad' \
|
|
-e 's/.*/BAD_VERSION/p' \
|
|
-e 'q'`
|
|
if test "x$OBJCOPY_VERSION_CHECK" = xBAD_VERSION; then
|
|
OBJCOPY=
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring found objcopy since it is broken (prior to 2.21.1). No debug symbols will be generated." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring found objcopy since it is broken (prior to 2.21.1). No debug symbols will be generated." >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: objcopy reports version $OBJCOPY_VERSION" >&5
|
|
$as_echo "$as_me: objcopy reports version $OBJCOPY_VERSION" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Note: patch 149063-01 or newer contains the correct Solaris 10 SPARC version" >&5
|
|
$as_echo "$as_me: Note: patch 149063-01 or newer contains the correct Solaris 10 SPARC version" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Note: patch 149064-01 or newer contains the correct Solaris 10 X86 version" >&5
|
|
$as_echo "$as_me: Note: patch 149064-01 or newer contains the correct Solaris 10 X86 version" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Note: Solaris 11 Update 1 contains the correct version" >&5
|
|
$as_echo "$as_me: Note: Solaris 11 Update 1 contains the correct version" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${OBJDUMP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in gobjdump objdump
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_OBJDUMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$OBJDUMP"; then
|
|
ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
OBJDUMP=$ac_cv_prog_OBJDUMP
|
|
if test -n "$OBJDUMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
|
|
$as_echo "$OBJDUMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$OBJDUMP" && break
|
|
done
|
|
fi
|
|
if test -z "$OBJDUMP"; then
|
|
ac_ct_OBJDUMP=$OBJDUMP
|
|
for ac_prog in gobjdump objdump
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_OBJDUMP"; then
|
|
ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
|
|
if test -n "$ac_ct_OBJDUMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
|
|
$as_echo "$ac_ct_OBJDUMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_OBJDUMP" && break
|
|
done
|
|
|
|
if test "x$ac_ct_OBJDUMP" = x; then
|
|
OBJDUMP=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
OBJDUMP=$ac_ct_OBJDUMP
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !OBJDUMP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OBJDUMP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xOBJDUMP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
if test -n "$ac_tool_prefix"; then
|
|
for ac_prog in gobjdump objdump
|
|
do
|
|
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_OBJDUMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$OBJDUMP"; then
|
|
ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
OBJDUMP=$ac_cv_prog_OBJDUMP
|
|
if test -n "$OBJDUMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
|
|
$as_echo "$OBJDUMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$OBJDUMP" && break
|
|
done
|
|
fi
|
|
if test -z "$OBJDUMP"; then
|
|
ac_ct_OBJDUMP=$OBJDUMP
|
|
for ac_prog in gobjdump objdump
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$ac_ct_OBJDUMP"; then
|
|
ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
|
|
if test -n "$ac_ct_OBJDUMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
|
|
$as_echo "$ac_ct_OBJDUMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ac_ct_OBJDUMP" && break
|
|
done
|
|
|
|
if test "x$ac_ct_OBJDUMP" = x; then
|
|
OBJDUMP=""
|
|
else
|
|
case $cross_compiling:$ac_tool_warned in
|
|
yes:)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
|
|
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
|
|
ac_tool_warned=yes ;;
|
|
esac
|
|
OBJDUMP=$ac_ct_OBJDUMP
|
|
fi
|
|
fi
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$OBJDUMP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool OBJDUMP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool OBJDUMP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
|
|
$as_echo_n "checking for OBJDUMP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$OBJDUMP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_OBJDUMP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $OBJDUMP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_OBJDUMP="$OBJDUMP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_OBJDUMP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
OBJDUMP=$ac_cv_path_OBJDUMP
|
|
if test -n "$OBJDUMP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
|
|
$as_echo "$OBJDUMP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$OBJDUMP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
|
|
$as_echo_n "checking for OBJDUMP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool OBJDUMP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$OBJDUMP" != x; then
|
|
# Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE
|
|
# bails if argument is missing.
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$OBJDUMP" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$OBJDUMP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$OBJDUMP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$OBJDUMP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
OBJDUMP="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJDUMP to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# Restore old path, except for the microsoft toolchain, which requires VS_PATH
|
|
# to remain in place. Otherwise the compiler will not work in some siutations
|
|
# in later configure checks.
|
|
if test "x$TOOLCHAIN_TYPE" != "xmicrosoft"; then
|
|
PATH="$OLD_PATH"
|
|
fi
|
|
|
|
# Restore the flags to the user specified values.
|
|
# This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"
|
|
CFLAGS="$ORG_CFLAGS"
|
|
CXXFLAGS="$ORG_CXXFLAGS"
|
|
|
|
|
|
# Finally do some processing after the detection phase
|
|
|
|
if test "x$COMPILE_TYPE" = "xcross"; then
|
|
# Now we need to find a C/C++ compiler that can build executables for the
|
|
# build platform. We can't use the AC_PROG_CC macro, since it can only be
|
|
# used once. Also, we need to do this without adding a tools dir to the
|
|
# path, otherwise we might pick up cross-compilers which don't use standard
|
|
# naming.
|
|
|
|
OLDPATH="$PATH"
|
|
|
|
|
|
# Check whether --with-build-devkit was given.
|
|
if test "${with_build_devkit+set}" = set; then :
|
|
withval=$with_build_devkit;
|
|
fi
|
|
|
|
if test "x$with_build_devkit" = "xyes"; then
|
|
as_fn_error $? "--with-build-devkit must have a value" "$LINENO" 5
|
|
elif test -n "$with_build_devkit"; then
|
|
if test ! -d "$with_build_devkit"; then
|
|
as_fn_error $? "--with-build-devkit points to non existing dir: $with_build_devkit" "$LINENO" 5
|
|
else
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$with_build_devkit" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$with_build_devkit"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of with_build_devkit" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
with_build_devkit="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_build_devkit to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting with_build_devkit to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$with_build_devkit"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
with_build_devkit="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_build_devkit to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting with_build_devkit to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$with_build_devkit"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of with_build_devkit, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of with_build_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
with_build_devkit="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
with_build_devkit="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
BUILD_DEVKIT_ROOT="$with_build_devkit"
|
|
# Check for a meta data info file in the root of the devkit
|
|
if test -f "$BUILD_DEVKIT_ROOT/devkit.info"; then
|
|
# Process devkit.info so that existing devkit variables are not
|
|
# modified by this
|
|
$SED -e "s/^DEVKIT_/BUILD_DEVKIT_/g" \
|
|
-e "s/\$DEVKIT_ROOT/\$BUILD_DEVKIT_ROOT/g" \
|
|
-e "s/\$host/\$build/g" \
|
|
$BUILD_DEVKIT_ROOT/devkit.info \
|
|
> $CONFIGURESUPPORT_OUTPUTDIR/build-devkit.info
|
|
. $CONFIGURESUPPORT_OUTPUTDIR/build-devkit.info
|
|
# This potentially sets the following:
|
|
# A descriptive name of the devkit
|
|
|
|
if test "x$BUILD_DEVKIT_NAME" = x; then
|
|
eval BUILD_DEVKIT_NAME="\${BUILD_DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-extra-path
|
|
|
|
if test "x$BUILD_DEVKIT_EXTRA_PATH" = x; then
|
|
eval BUILD_DEVKIT_EXTRA_PATH="\${BUILD_DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-toolchain-path
|
|
|
|
if test "x$BUILD_DEVKIT_TOOLCHAIN_PATH" = x; then
|
|
eval BUILD_DEVKIT_TOOLCHAIN_PATH="\${BUILD_DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Corresponds to --with-sysroot
|
|
|
|
if test "x$BUILD_DEVKIT_SYSROOT" = x; then
|
|
eval BUILD_DEVKIT_SYSROOT="\${BUILD_DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
|
|
fi
|
|
|
|
# Skip the Window specific parts
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for build platform devkit" >&5
|
|
$as_echo_n "checking for build platform devkit... " >&6; }
|
|
if test "x$BUILD_DEVKIT_NAME" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_DEVKIT_NAME in $BUILD_DEVKIT_ROOT" >&5
|
|
$as_echo "$BUILD_DEVKIT_NAME in $BUILD_DEVKIT_ROOT" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_DEVKIT_ROOT" >&5
|
|
$as_echo "$BUILD_DEVKIT_ROOT" >&6; }
|
|
fi
|
|
|
|
BUILD_SYSROOT="$BUILD_DEVKIT_SYSROOT"
|
|
|
|
if test "x$BUILD_SYSROOT" != "x"; then
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
# Solaris Studio does not have a concept of sysroot. Instead we must
|
|
# make sure the default include and lib dirs are appended to each
|
|
# compile and link command line. Must also add -I-xbuiltin to enable
|
|
# inlining of system functions and intrinsics.
|
|
BUILD_SYSROOT_CFLAGS="-I-xbuiltin -I$BUILD_SYSROOT/usr/include"
|
|
BUILD_SYSROOT_LDFLAGS="-L$BUILD_SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
|
|
-L$BUILD_SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
BUILD_SYSROOT_CFLAGS="--sysroot=$BUILD_SYSROOT"
|
|
BUILD_SYSROOT_LDFLAGS="--sysroot=$BUILD_SYSROOT"
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
BUILD_SYSROOT_CFLAGS="-isysroot $BUILD_SYSROOT"
|
|
BUILD_SYSROOT_LDFLAGS="-isysroot $BUILD_SYSROOT"
|
|
fi
|
|
# The global CFLAGS and LDFLAGS variables need these for configure to function
|
|
BUILD_CFLAGS="$BUILD_CFLAGS $BUILD_SYSROOT_CFLAGS"
|
|
BUILD_CPPFLAGS="$BUILD_CPPFLAGS $BUILD_SYSROOT_CFLAGS"
|
|
BUILD_CXXFLAGS="$BUILD_CXXFLAGS $BUILD_SYSROOT_CFLAGS"
|
|
BUILD_LDFLAGS="$BUILD_LDFLAGS $BUILD_SYSROOT_LDFLAGS"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# We also need -iframework<path>/System/Library/Frameworks
|
|
BUILD_SYSROOT_CFLAGS="$BUILD_SYSROOT_CFLAGS -iframework $BUILD_SYSROOT/System/Library/Frameworks"
|
|
BUILD_SYSROOT_LDFLAGS="$BUILD_SYSROOT_LDFLAGS -iframework $BUILD_SYSROOT/System/Library/Frameworks"
|
|
# These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
|
|
# set this here so it doesn't have to be peppered throughout the forest
|
|
BUILD_SYSROOT_CFLAGS="$BUILD_SYSROOT_CFLAGS -F $BUILD_SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
|
|
BUILD_SYSROOT_LDFLAGS="$BUILD_SYSROOT_LDFLAGS -F $BUILD_SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Fallback default of just /bin if DEVKIT_PATH is not defined
|
|
if test "x$BUILD_DEVKIT_TOOLCHAIN_PATH" = x; then
|
|
BUILD_DEVKIT_TOOLCHAIN_PATH="$BUILD_DEVKIT_ROOT/bin"
|
|
fi
|
|
PATH="$BUILD_DEVKIT_TOOLCHAIN_PATH:$BUILD_DEVKIT_EXTRA_PATH"
|
|
fi
|
|
fi
|
|
|
|
# FIXME: we should list the discovered compilers as an exclude pattern!
|
|
# If we do that, we can do this detection before POST_DETECTION, and still
|
|
# find the build compilers in the tools dir, if needed.
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BUILD_CC+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cl cc gcc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_CC=$ac_cv_path_BUILD_CC
|
|
if test -n "$BUILD_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
|
|
$as_echo "$BUILD_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_CC" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BUILD_CC! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_CC!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBUILD_CC" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cl cc gcc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_CC=$ac_cv_path_BUILD_CC
|
|
if test -n "$BUILD_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
|
|
$as_echo "$BUILD_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_CC" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BUILD_CC" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_CC= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BUILD_CC= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
|
|
$as_echo_n "checking for BUILD_CC... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BUILD_CC"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_CC+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_CC in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_CC=$ac_cv_path_BUILD_CC
|
|
if test -n "$BUILD_CC"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
|
|
$as_echo "$BUILD_CC" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BUILD_CC" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
|
|
$as_echo_n "checking for BUILD_CC... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$BUILD_CC" = x; then
|
|
as_fn_error $? "Could not find required tool for BUILD_CC" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_CC" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_CC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_CC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_CC"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
BUILD_CC="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BUILD_CXX+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in cl CC g++
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_CXX=$ac_cv_path_BUILD_CXX
|
|
if test -n "$BUILD_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
|
|
$as_echo "$BUILD_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_CXX" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BUILD_CXX! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_CXX!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBUILD_CXX" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in cl CC g++
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_CXX=$ac_cv_path_BUILD_CXX
|
|
if test -n "$BUILD_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
|
|
$as_echo "$BUILD_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_CXX" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BUILD_CXX" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_CXX= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BUILD_CXX= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
|
|
$as_echo_n "checking for BUILD_CXX... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BUILD_CXX"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_CXX+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_CXX in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_CXX=$ac_cv_path_BUILD_CXX
|
|
if test -n "$BUILD_CXX"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
|
|
$as_echo "$BUILD_CXX" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BUILD_CXX" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
|
|
$as_echo_n "checking for BUILD_CXX... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$BUILD_CXX" = x; then
|
|
as_fn_error $? "Could not find required tool for BUILD_CXX" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_CXX" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_CXX"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_CXX"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_CXX"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
BUILD_CXX="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BUILD_NM+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in nm gcc-nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_NM="$BUILD_NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_NM=$ac_cv_path_BUILD_NM
|
|
if test -n "$BUILD_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_NM" >&5
|
|
$as_echo "$BUILD_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_NM" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BUILD_NM! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_NM!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBUILD_NM" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_NM from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BUILD_NM from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in nm gcc-nm
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_NM="$BUILD_NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_NM=$ac_cv_path_BUILD_NM
|
|
if test -n "$BUILD_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_NM" >&5
|
|
$as_echo "$BUILD_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_NM" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BUILD_NM" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_NM= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BUILD_NM= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_NM" >&5
|
|
$as_echo_n "checking for BUILD_NM... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BUILD_NM"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_NM=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BUILD_NM=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_NM+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_NM in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_NM="$BUILD_NM" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_NM="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_NM=$ac_cv_path_BUILD_NM
|
|
if test -n "$BUILD_NM"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_NM" >&5
|
|
$as_echo "$BUILD_NM" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BUILD_NM" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_NM=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BUILD_NM=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_NM" >&5
|
|
$as_echo_n "checking for BUILD_NM... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BUILD_NM=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_NM" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_NM, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_NM"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_NM, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_NM" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
BUILD_NM="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_NM to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_NM to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BUILD_AR+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in ar gcc-ar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_AR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_AR="$BUILD_AR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_AR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_AR=$ac_cv_path_BUILD_AR
|
|
if test -n "$BUILD_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_AR" >&5
|
|
$as_echo "$BUILD_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_AR" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BUILD_AR! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_AR!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBUILD_AR" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_AR from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BUILD_AR from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in ar gcc-ar
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_AR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_AR="$BUILD_AR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_AR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_AR=$ac_cv_path_BUILD_AR
|
|
if test -n "$BUILD_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_AR" >&5
|
|
$as_echo "$BUILD_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_AR" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BUILD_AR" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_AR= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BUILD_AR= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_AR" >&5
|
|
$as_echo_n "checking for BUILD_AR... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BUILD_AR"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_AR=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BUILD_AR=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_AR+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_AR in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_AR="$BUILD_AR" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_AR="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_AR=$ac_cv_path_BUILD_AR
|
|
if test -n "$BUILD_AR"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_AR" >&5
|
|
$as_echo "$BUILD_AR" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BUILD_AR" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_AR=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BUILD_AR=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_AR" >&5
|
|
$as_echo_n "checking for BUILD_AR... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BUILD_AR=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_AR" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_AR"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_AR, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_AR"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_AR"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_AR, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_AR" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
BUILD_AR="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_AR to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_AR to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BUILD_OBJCOPY+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in objcopy
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_OBJCOPY in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_OBJCOPY="$BUILD_OBJCOPY" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_OBJCOPY=$ac_cv_path_BUILD_OBJCOPY
|
|
if test -n "$BUILD_OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_OBJCOPY" >&5
|
|
$as_echo "$BUILD_OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_OBJCOPY" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BUILD_OBJCOPY! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_OBJCOPY!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBUILD_OBJCOPY" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_OBJCOPY from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BUILD_OBJCOPY from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in objcopy
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_OBJCOPY in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_OBJCOPY="$BUILD_OBJCOPY" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_OBJCOPY=$ac_cv_path_BUILD_OBJCOPY
|
|
if test -n "$BUILD_OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_OBJCOPY" >&5
|
|
$as_echo "$BUILD_OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_OBJCOPY" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BUILD_OBJCOPY" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_OBJCOPY= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BUILD_OBJCOPY= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_OBJCOPY" >&5
|
|
$as_echo_n "checking for BUILD_OBJCOPY... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BUILD_OBJCOPY"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_OBJCOPY=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BUILD_OBJCOPY=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_OBJCOPY+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_OBJCOPY in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_OBJCOPY="$BUILD_OBJCOPY" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_OBJCOPY=$ac_cv_path_BUILD_OBJCOPY
|
|
if test -n "$BUILD_OBJCOPY"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_OBJCOPY" >&5
|
|
$as_echo "$BUILD_OBJCOPY" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BUILD_OBJCOPY" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_OBJCOPY=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BUILD_OBJCOPY=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_OBJCOPY" >&5
|
|
$as_echo_n "checking for BUILD_OBJCOPY... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BUILD_OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_OBJCOPY" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_OBJCOPY"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_OBJCOPY"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_OBJCOPY"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_OBJCOPY" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
BUILD_OBJCOPY="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_OBJCOPY to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_OBJCOPY to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${BUILD_STRIP+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_STRIP="$BUILD_STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_STRIP=$ac_cv_path_BUILD_STRIP
|
|
if test -n "$BUILD_STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_STRIP" >&5
|
|
$as_echo "$BUILD_STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_STRIP" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !BUILD_STRIP! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BUILD_STRIP!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xBUILD_STRIP" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_STRIP from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of BUILD_STRIP from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in strip
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_STRIP="$BUILD_STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_STRIP=$ac_cv_path_BUILD_STRIP
|
|
if test -n "$BUILD_STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_STRIP" >&5
|
|
$as_echo "$BUILD_STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$BUILD_STRIP" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$BUILD_STRIP" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool BUILD_STRIP= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool BUILD_STRIP= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_STRIP" >&5
|
|
$as_echo_n "checking for BUILD_STRIP... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$BUILD_STRIP"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_STRIP=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool BUILD_STRIP=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_BUILD_STRIP+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $BUILD_STRIP in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_BUILD_STRIP="$BUILD_STRIP" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_BUILD_STRIP="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
BUILD_STRIP=$ac_cv_path_BUILD_STRIP
|
|
if test -n "$BUILD_STRIP"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_STRIP" >&5
|
|
$as_echo "$BUILD_STRIP" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$BUILD_STRIP" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_STRIP=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool BUILD_STRIP=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_STRIP" >&5
|
|
$as_echo_n "checking for BUILD_STRIP... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool BUILD_STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$BUILD_STRIP" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$BUILD_STRIP"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of BUILD_STRIP, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of BUILD_STRIP" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
BUILD_STRIP="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_STRIP to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting BUILD_STRIP to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
# Assume the C compiler is the assembler
|
|
BUILD_AS="$BUILD_CC -c"
|
|
# Just like for the target compiler, use the compiler as linker
|
|
BUILD_LD="$BUILD_CC"
|
|
BUILD_LDCXX="$BUILD_CXX"
|
|
|
|
PATH="$OLDPATH"
|
|
|
|
|
|
COMPILER=$BUILD_CC
|
|
COMPILER_NAME=BuildC
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
# cc -V output typically looks like
|
|
# cc: Sun C 5.12 Linux_i386 2011/11/16
|
|
# or
|
|
# cc: Studio 12.5 Sun C 5.14 SunOS_sparc 2016/05/31
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
|
|
# Check that this is likely to be the Solaris Studio cc.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.* Sun $COMPILER_NAME" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove usage instructions (if present), and
|
|
# collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *[Uu]sage:.*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
# xlc -qversion output typically looks like
|
|
# IBM XL C/C++ for AIX, V11.1 (5724-X13)
|
|
# Version: 11.01.0000.0015
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
|
|
# Check that this is likely to be the IBM XL C compiler.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# There is no specific version flag, but all output starts with a version string.
|
|
# First line typically looks something like:
|
|
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
|
|
# Check that this is likely to be Microsoft CL.EXE.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# gcc --version output typically looks like
|
|
# gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
|
|
# Copyright (C) 2013 Free Software Foundation, Inc.
|
|
# This is free software; see the source for copying conditions. There is NO
|
|
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be GCC.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove Copyright and legalese from version string, and
|
|
# collapse into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *Copyright .*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
# clang --version output typically looks like
|
|
# Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
|
|
# clang version 3.3 (tags/RELEASE_33/final)
|
|
# or
|
|
# Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
|
|
# Target: x86_64-pc-linux-gnu
|
|
# Thread model: posix
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be clang
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
|
|
else
|
|
as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
|
|
fi
|
|
# This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
|
|
BUILD_CC_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
|
|
# This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
|
|
BUILD_CC_VERSION_STRING="$COMPILER_VERSION_STRING"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
|
|
$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
|
|
|
|
|
|
COMPILER=$BUILD_CXX
|
|
COMPILER_NAME=BuildC++
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
# cc -V output typically looks like
|
|
# cc: Sun C 5.12 Linux_i386 2011/11/16
|
|
# or
|
|
# cc: Studio 12.5 Sun C 5.14 SunOS_sparc 2016/05/31
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
|
|
# Check that this is likely to be the Solaris Studio cc.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.* Sun $COMPILER_NAME" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove usage instructions (if present), and
|
|
# collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *[Uu]sage:.*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
# xlc -qversion output typically looks like
|
|
# IBM XL C/C++ for AIX, V11.1 (5724-X13)
|
|
# Version: 11.01.0000.0015
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
|
|
# Check that this is likely to be the IBM XL C compiler.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
|
|
if test $? -ne 0; then
|
|
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# There is no specific version flag, but all output starts with a version string.
|
|
# First line typically looks something like:
|
|
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
|
|
# Check that this is likely to be Microsoft CL.EXE.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# gcc --version output typically looks like
|
|
# gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
|
|
# Copyright (C) 2013 Free Software Foundation, Inc.
|
|
# This is free software; see the source for copying conditions. There is NO
|
|
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be GCC.
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Remove Copyright and legalese from version string, and
|
|
# collapse into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/ *Copyright .*//'`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
# clang --version output typically looks like
|
|
# Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
|
|
# clang version 3.3 (tags/RELEASE_33/final)
|
|
# or
|
|
# Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
|
|
# Target: x86_64-pc-linux-gnu
|
|
# Thread model: posix
|
|
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
|
|
# Check that this is likely to be clang
|
|
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
|
|
if test $? -ne 0; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
|
|
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
|
|
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
|
|
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
|
|
fi
|
|
# Collapse compiler output into a single line
|
|
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
|
|
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
|
|
$SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
|
|
else
|
|
as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
|
|
fi
|
|
# This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
|
|
BUILD_CXX_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
|
|
# This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
|
|
BUILD_CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
|
|
$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
|
|
|
|
|
|
if test "x$BUILD_CC_VERSION_NUMBER" != "x$BUILD_CXX_VERSION_NUMBER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $BUILD_CC_VERSION_NUMBER vs $BUILD_CXX_VERSION_NUMBER." >&5
|
|
$as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $BUILD_CC_VERSION_NUMBER vs $BUILD_CXX_VERSION_NUMBER." >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
|
|
$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
|
|
fi
|
|
|
|
# We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
|
|
if [[ "[$]BUILD_CC_VERSION_NUMBER" =~ (.*\.){4} ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than four parts (W.X.Y.Z): $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&5
|
|
$as_echo "$as_me: WARNING: C compiler version number has more than four parts (W.X.Y.Z): $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
|
|
fi
|
|
|
|
if [[ "[$]BUILD_CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&5
|
|
$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
|
|
fi
|
|
|
|
OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$BUILD_CC_VERSION_NUMBER"`
|
|
|
|
else
|
|
# If we are not cross compiling, use the normal target compilers for
|
|
# building the build platform executables.
|
|
BUILD_CC="$CC"
|
|
BUILD_CXX="$CXX"
|
|
BUILD_LD="$LD"
|
|
BUILD_LDCXX="$LDCXX"
|
|
BUILD_NM="$NM"
|
|
BUILD_AS="$AS"
|
|
BUILD_OBJCOPY="$OBJCOPY"
|
|
BUILD_STRIP="$STRIP"
|
|
BUILD_SYSROOT_CFLAGS="$SYSROOT_CFLAGS"
|
|
BUILD_SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS"
|
|
BUILD_AR="$AR"
|
|
|
|
|
|
if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
|
|
$as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
|
|
$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
|
|
fi
|
|
|
|
# We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
|
|
if [[ "[$]CC_VERSION_NUMBER" =~ (.*\.){4} ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than four parts (W.X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
|
|
$as_echo "$as_me: WARNING: C compiler version number has more than four parts (W.X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
|
|
fi
|
|
|
|
if [[ "[$]CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
|
|
$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
|
|
fi
|
|
|
|
OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$CC_VERSION_NUMBER"`
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# The package path is used only on macosx?
|
|
# FIXME: clean this up, and/or move it elsewhere.
|
|
PACKAGE_PATH=/opt/local
|
|
|
|
|
|
# Check for extra potential brokenness.
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# On Windows, double-check that we got the right compiler.
|
|
CC_VERSION_OUTPUT=`$CC 2>&1 | $HEAD -n 1 | $TR -d '\r'`
|
|
COMPILER_CPU_TEST=`$ECHO $CC_VERSION_OUTPUT | $SED -n "s/^.* \(.*\)$/\1/p"`
|
|
if test "x$OPENJDK_TARGET_CPU" = "xx86"; then
|
|
if test "x$COMPILER_CPU_TEST" != "x80x86" -a "x$COMPILER_CPU_TEST" != "xx86"; then
|
|
as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"80x86\" or \"x86\"." "$LINENO" 5
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
|
|
if test "x$COMPILER_CPU_TEST" != "xx64"; then
|
|
as_fn_error $? "Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for \"$COMPILER_CPU_TEST\"; expected \"x64\"." "$LINENO" 5
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# If this is a --hash-style=gnu system, use --hash-style=both, why?
|
|
HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
|
|
# This is later checked when setting flags.
|
|
|
|
# "-Og" suppported for GCC 4.8 and later
|
|
CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
|
|
$as_echo_n "checking if the C compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cflags="$CFLAGS"
|
|
CFLAGS="$CFLAGS $CFLAG_OPTIMIZE_DEBUG_FLAG"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CFLAGS="$saved_cflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
C_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
C_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG $CFLAG_OPTIMIZE_DEBUG_FLAG"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
CXX_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
CXX_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
|
|
$as_echo_n "checking if both compilers support \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
|
|
supports=no
|
|
if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
HAS_CFLAG_OPTIMIZE_DEBUG=true
|
|
else
|
|
:
|
|
HAS_CFLAG_OPTIMIZE_DEBUG=false
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# "-z relro" supported in GNU binutils 2.17 and later
|
|
LINKER_RELRO_FLAG="-Wl,-z,relro"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if linker supports \"$LINKER_RELRO_FLAG\"" >&5
|
|
$as_echo_n "checking if linker supports \"$LINKER_RELRO_FLAG\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_ldflags="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS $LINKER_RELRO_FLAG"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_link "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
LDFLAGS="$saved_ldflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
HAS_LINKER_RELRO=true
|
|
else
|
|
:
|
|
HAS_LINKER_RELRO=false
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# "-z now" supported in GNU binutils 2.11 and later
|
|
LINKER_NOW_FLAG="-Wl,-z,now"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if linker supports \"$LINKER_NOW_FLAG\"" >&5
|
|
$as_echo_n "checking if linker supports \"$LINKER_NOW_FLAG\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_ldflags="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS $LINKER_NOW_FLAG"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_link "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
LDFLAGS="$saved_ldflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
HAS_LINKER_NOW=true
|
|
else
|
|
:
|
|
HAS_LINKER_NOW=false
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fi
|
|
|
|
# Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
|
|
# in executable.'
|
|
USING_BROKEN_SUSE_LD=no
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
|
|
$as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
|
|
$ECHO "SUNWprivate_1.1 { local: *; };" > version-script.map
|
|
$ECHO "int main() { }" > main.c
|
|
if $CXX -Wl,-version-script=version-script.map main.c 2>&5 >&5; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
USING_BROKEN_SUSE_LD=no
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
USING_BROKEN_SUSE_LD=yes
|
|
fi
|
|
$RM version-script.map main.c a.out
|
|
fi
|
|
|
|
|
|
# Setup hotspot lecagy names for toolchains
|
|
HOTSPOT_TOOLCHAIN_TYPE=$TOOLCHAIN_TYPE
|
|
if test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
HOTSPOT_TOOLCHAIN_TYPE=gcc
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
HOTSPOT_TOOLCHAIN_TYPE=sparcWorks
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
HOTSPOT_TOOLCHAIN_TYPE=visCPP
|
|
fi
|
|
|
|
|
|
|
|
# Setup the JTReg Regression Test Harness.
|
|
|
|
|
|
# Check whether --with-jtreg was given.
|
|
if test "${with_jtreg+set}" = set; then :
|
|
withval=$with_jtreg;
|
|
fi
|
|
|
|
|
|
if test "x$with_jtreg" = xno; then
|
|
# jtreg disabled
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg test harness" >&5
|
|
$as_echo_n "checking for jtreg test harness... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabled" >&5
|
|
$as_echo "no, disabled" >&6; }
|
|
elif test "x$with_jtreg" != xyes && test "x$with_jtreg" != x; then
|
|
# An explicit path is specified, use it.
|
|
JT_HOME="$with_jtreg"
|
|
if test ! -d "$JT_HOME"; then
|
|
as_fn_error $? "jtreg home directory from --with-jtreg=$with_jtreg does not exist" "$LINENO" 5
|
|
fi
|
|
|
|
if test ! -e "$JT_HOME/lib/jtreg.jar"; then
|
|
as_fn_error $? "jtreg home directory from --with-jtreg=$with_jtreg is not a valid jtreg home" "$LINENO" 5
|
|
fi
|
|
|
|
JTREGEXE="$JT_HOME/bin/jtreg"
|
|
if test ! -x "$JTREGEXE"; then
|
|
as_fn_error $? "jtreg home directory from --with-jtreg=$with_jtreg does not contain valid jtreg executable" "$LINENO" 5
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg test harness" >&5
|
|
$as_echo_n "checking for jtreg test harness... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JT_HOME" >&5
|
|
$as_echo "$JT_HOME" >&6; }
|
|
else
|
|
# Try to locate jtreg
|
|
if test "x$JT_HOME" != x; then
|
|
# JT_HOME set in environment, use it
|
|
if test ! -d "$JT_HOME"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring JT_HOME pointing to invalid directory: $JT_HOME" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring JT_HOME pointing to invalid directory: $JT_HOME" >&2;}
|
|
JT_HOME=
|
|
else
|
|
if test ! -e "$JT_HOME/lib/jtreg.jar"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring JT_HOME which is not a valid jtreg home: $JT_HOME" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring JT_HOME which is not a valid jtreg home: $JT_HOME" >&2;}
|
|
JT_HOME=
|
|
elif test ! -x "$JT_HOME/bin/jtreg"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring JT_HOME which does not contain valid jtreg executable: $JT_HOME" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring JT_HOME which does not contain valid jtreg executable: $JT_HOME" >&2;}
|
|
JT_HOME=
|
|
else
|
|
JTREGEXE="$JT_HOME/bin/jtreg"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Located jtreg using JT_HOME from environment" >&5
|
|
$as_echo "$as_me: Located jtreg using JT_HOME from environment" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$JT_HOME" = x; then
|
|
# JT_HOME is not set in environment, or was deemed invalid.
|
|
# Try to find jtreg on path
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${JTREGEXE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in jtreg
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JTREGEXE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JTREGEXE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JTREGEXE=$ac_cv_path_JTREGEXE
|
|
if test -n "$JTREGEXE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
|
|
$as_echo "$JTREGEXE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$JTREGEXE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !JTREGEXE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!JTREGEXE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xJTREGEXE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in jtreg
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JTREGEXE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JTREGEXE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JTREGEXE=$ac_cv_path_JTREGEXE
|
|
if test -n "$JTREGEXE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
|
|
$as_echo "$JTREGEXE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$JTREGEXE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$JTREGEXE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool JTREGEXE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool JTREGEXE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
|
|
$as_echo_n "checking for JTREGEXE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$JTREGEXE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_JTREGEXE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $JTREGEXE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
JTREGEXE=$ac_cv_path_JTREGEXE
|
|
if test -n "$JTREGEXE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
|
|
$as_echo "$JTREGEXE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$JTREGEXE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
|
|
$as_echo_n "checking for JTREGEXE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool JTREGEXE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$JTREGEXE" != x; then
|
|
# That's good, now try to derive JT_HOME
|
|
JT_HOME=`(cd $($DIRNAME $JTREGEXE)/.. && pwd)`
|
|
if test ! -e "$JT_HOME/lib/jtreg.jar"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring jtreg from path since a valid jtreg home cannot be found" >&5
|
|
$as_echo "$as_me: WARNING: Ignoring jtreg from path since a valid jtreg home cannot be found" >&2;}
|
|
JT_HOME=
|
|
JTREGEXE=
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Located jtreg using jtreg executable in path" >&5
|
|
$as_echo "$as_me: Located jtreg using jtreg executable in path" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg test harness" >&5
|
|
$as_echo_n "checking for jtreg test harness... " >&6; }
|
|
if test "x$JT_HOME" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JT_HOME" >&5
|
|
$as_echo "$JT_HOME" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, not found" >&5
|
|
$as_echo "no, not found" >&6; }
|
|
|
|
if test "x$with_jtreg" = xyes; then
|
|
as_fn_error $? "--with-jtreg was specified, but no jtreg found." "$LINENO" 5
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$JTREGEXE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$JTREGEXE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in cygwin causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path=`$CYGPATH -u "$path"`
|
|
fi
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JTREGEXE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of JTREGEXE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of JTREGEXE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
# Short path failed, file does not exist as specified.
|
|
# Try adding .exe or .cmd
|
|
if test -f "${new_path}.exe"; then
|
|
input_to_shortpath="${new_path}.exe"
|
|
elif test -f "${new_path}.cmd"; then
|
|
input_to_shortpath="${new_path}.cmd"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JTREGEXE, which resolves as \"$new_path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of JTREGEXE, which resolves as \"$new_path\", is invalid." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
|
|
$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
|
|
as_fn_error $? "Cannot locate the the path of JTREGEXE" "$LINENO" 5
|
|
fi
|
|
else
|
|
input_to_shortpath="$new_path"
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
new_path="$input_to_shortpath"
|
|
|
|
input_path="$input_to_shortpath"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$JTREGEXE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
# Now try to locate executable using which
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
|
|
if test "x$new_path" = x; then
|
|
# Oops. Which didn't find the executable.
|
|
# The splitting of arguments from the executable at a space might have been incorrect,
|
|
# since paths with space are more likely in Windows. Give it another try with the whole
|
|
# argument.
|
|
path="$complete"
|
|
arguments="EOL"
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
|
|
new_path=`$WHICH "$new_path" 2> /dev/null`
|
|
# bat and cmd files are not always considered executable in MSYS causing which
|
|
# to not find them
|
|
if test "x$new_path" = x \
|
|
&& test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
|
|
&& test "x`$LS \"$path\" 2>/dev/null`" != x; then
|
|
new_path="$path"
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
# It's still not found. Now this is an unrecoverable error.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JTREGEXE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of JTREGEXE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
|
|
$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of JTREGEXE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now new_path has a complete unix path to the binary
|
|
if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
|
|
# Keep paths in /bin as-is, but remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
# Do not save /bin paths to all_fixpath_prefixes!
|
|
else
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $new_path`
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
# Output is in $new_path
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
# remove trailing .exe if any
|
|
new_path="${new_path/%.exe/}"
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
fi
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
# First separate the path from the arguments. This will split at the first
|
|
# space.
|
|
complete="$JTREGEXE"
|
|
path="${complete%% *}"
|
|
tmp="$complete EOL"
|
|
arguments="${tmp#* }"
|
|
|
|
# Cannot rely on the command "which" here since it doesn't always work.
|
|
is_absolute_path=`$ECHO "$path" | $GREP ^/`
|
|
if test -z "$is_absolute_path"; then
|
|
# Path to executable is not absolute. Find it.
|
|
IFS_save="$IFS"
|
|
IFS=:
|
|
for p in $PATH; do
|
|
if test -f "$p/$path" && test -x "$p/$path"; then
|
|
new_path="$p/$path"
|
|
break
|
|
fi
|
|
done
|
|
IFS="$IFS_save"
|
|
else
|
|
# This is an absolute path, we can use it without further modifications.
|
|
new_path="$path"
|
|
fi
|
|
|
|
if test "x$new_path" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JTREGEXE, which resolves as \"$complete\", is not found." >&5
|
|
$as_echo "$as_me: The path of JTREGEXE, which resolves as \"$complete\", is not found." >&6;}
|
|
has_space=`$ECHO "$complete" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
|
|
$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot locate the the path of JTREGEXE" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Now join together the path and the arguments once again
|
|
if test "x$arguments" != xEOL; then
|
|
new_complete="$new_path ${arguments% *}"
|
|
else
|
|
new_complete="$new_path"
|
|
fi
|
|
|
|
if test "x$complete" != "x$new_complete"; then
|
|
JTREGEXE="$new_complete"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JTREGEXE to \"$new_complete\"" >&5
|
|
$as_echo "$as_me: Rewriting JTREGEXE to \"$new_complete\"" >&6;}
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$JT_HOME" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$JT_HOME"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of JT_HOME" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
JT_HOME="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$JT_HOME"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
JT_HOME="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$JT_HOME"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of JT_HOME, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
JT_HOME="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
JT_HOME="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Setup Jib dependency tool
|
|
|
|
|
|
# Check whether --with-jib was given.
|
|
if test "${with_jib+set}" = set; then :
|
|
withval=$with_jib;
|
|
fi
|
|
|
|
|
|
if test "x$with_jib" = xno || test "x$with_jib" = x; then
|
|
# jib disabled
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jib" >&5
|
|
$as_echo_n "checking for jib... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
elif test "x$with_jib" = xyes; then
|
|
as_fn_error $? "Must supply a value to --with-jib" "$LINENO" 5
|
|
else
|
|
JIB_HOME="${with_jib}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jib" >&5
|
|
$as_echo_n "checking for jib... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${JIB_HOME}" >&5
|
|
$as_echo "${JIB_HOME}" >&6; }
|
|
if test ! -d "${JIB_HOME}"; then
|
|
as_fn_error $? "--with-jib must be a directory" "$LINENO" 5
|
|
fi
|
|
JIB_JAR=$(ls ${JIB_HOME}/lib/jib-*.jar)
|
|
if test ! -f "${JIB_JAR}"; then
|
|
as_fn_error $? "Could not find jib jar file in ${JIB_HOME}" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# COMPILER_TARGET_BITS_FLAG : option for selecting 32- or 64-bit output
|
|
# COMPILER_COMMAND_FILE_FLAG : option for passing a command file to the compiler
|
|
# COMPILER_BINDCMD_FILE_FLAG : option for specifying a file which saves the binder
|
|
# commands produced by the link step (currently AIX only)
|
|
if test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
COMPILER_TARGET_BITS_FLAG="-q"
|
|
COMPILER_COMMAND_FILE_FLAG="-f"
|
|
COMPILER_BINDCMD_FILE_FLAG="-bloadmap:"
|
|
else
|
|
COMPILER_TARGET_BITS_FLAG="-m"
|
|
COMPILER_COMMAND_FILE_FLAG="@"
|
|
COMPILER_BINDCMD_FILE_FLAG=""
|
|
|
|
# The solstudio linker does not support @-files.
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
COMPILER_COMMAND_FILE_FLAG=
|
|
fi
|
|
|
|
# Check if @file is supported by gcc
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if @file is supported by gcc" >&5
|
|
$as_echo_n "checking if @file is supported by gcc... " >&6; }
|
|
# Extra emtpy "" to prevent ECHO from interpreting '--version' as argument
|
|
$ECHO "" "--version" > command.file
|
|
if $CXX @command.file 2>&5 >&5; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
COMPILER_COMMAND_FILE_FLAG="@"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
COMPILER_COMMAND_FILE_FLAG=
|
|
fi
|
|
$RM command.file
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
# FIXME: figure out if we should select AR flags depending on OS or toolchain.
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
ARFLAGS="-r"
|
|
elif test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
ARFLAGS="-X64"
|
|
elif test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# lib.exe is used as AR to create static libraries.
|
|
ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
|
|
else
|
|
ARFLAGS=""
|
|
fi
|
|
|
|
|
|
## Setup strip.
|
|
# FIXME: should this really be per platform, or should it be per toolchain type?
|
|
# strip is not provided by clang or solstudio; so guessing platform makes most sense.
|
|
# FIXME: we should really only export STRIPFLAGS from here, not POST_STRIP_CMD.
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
STRIPFLAGS="-g"
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
STRIPFLAGS="-x"
|
|
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
STRIPFLAGS="-S"
|
|
elif test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
STRIPFLAGS="-X32_64"
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
CC_OUT_OPTION=-Fo
|
|
EXE_OUT_OPTION=-out:
|
|
LD_OUT_OPTION=-out:
|
|
AR_OUT_OPTION=-out:
|
|
else
|
|
# The option used to specify the target .o,.a or .so file.
|
|
# When compiling, how to specify the to be created object file.
|
|
CC_OUT_OPTION='-o$(SPACE)'
|
|
# When linking, how to specify the to be created executable.
|
|
EXE_OUT_OPTION='-o$(SPACE)'
|
|
# When linking, how to specify the to be created dynamically linkable library.
|
|
LD_OUT_OPTION='-o$(SPACE)'
|
|
# When archiving, how to specify the to be create static archive for object files.
|
|
AR_OUT_OPTION='rcs$(SPACE)'
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# On Windows, we need to set RC flags.
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
RC_FLAGS="-nologo -l0x409"
|
|
JVM_RCFLAGS="-nologo"
|
|
if test "x$DEBUG_LEVEL" = xrelease; then
|
|
RC_FLAGS="$RC_FLAGS -DNDEBUG"
|
|
JVM_RCFLAGS="$JVM_RCFLAGS -DNDEBUG"
|
|
fi
|
|
|
|
# The version variables used to create RC_FLAGS may be overridden
|
|
# in a custom configure script, or possibly the command line.
|
|
# Let those variables be expanded at make time in spec.gmk.
|
|
# The \$ are escaped to the shell, and the $(...) variables
|
|
# are evaluated by make.
|
|
RC_FLAGS="$RC_FLAGS \
|
|
-D\"JDK_VERSION_STRING=\$(VERSION_STRING)\" \
|
|
-D\"JDK_COMPANY=\$(COMPANY_NAME)\" \
|
|
-D\"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
|
|
-D\"JDK_VER=\$(VERSION_NUMBER)\" \
|
|
-D\"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
|
|
-D\"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(VERSION_MAJOR)\" \
|
|
-D\"JDK_FVER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\""
|
|
|
|
JVM_RCFLAGS="$JVM_RCFLAGS \
|
|
-D\"HS_BUILD_ID=\$(VERSION_STRING)\" \
|
|
-D\"HS_COMPANY=\$(COMPANY_NAME)\" \
|
|
-D\"JDK_DOTVER=\$(VERSION_NUMBER_FOUR_POSITIONS)\" \
|
|
-D\"HS_COPYRIGHT=Copyright $COPYRIGHT_YEAR\" \
|
|
-D\"HS_NAME=\$(PRODUCT_NAME) \$(VERSION_SHORT)\" \
|
|
-D\"JDK_VER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\" \
|
|
-D\"HS_FNAME=jvm.dll\" \
|
|
-D\"HS_INTERNAL_NAME=jvm\""
|
|
fi
|
|
|
|
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# silence copyright notice and other headers.
|
|
COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
|
|
fi
|
|
|
|
|
|
# Now we can test some aspects on the target using configure macros.
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
|
|
$as_echo_n "checking for ANSI C header files... " >&6; }
|
|
if ${ac_cv_header_stdc+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <float.h>
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_cv_header_stdc=yes
|
|
else
|
|
ac_cv_header_stdc=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
|
|
if test $ac_cv_header_stdc = yes; then
|
|
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <string.h>
|
|
|
|
_ACEOF
|
|
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
|
|
$EGREP "memchr" >/dev/null 2>&1; then :
|
|
|
|
else
|
|
ac_cv_header_stdc=no
|
|
fi
|
|
rm -f conftest*
|
|
|
|
fi
|
|
|
|
if test $ac_cv_header_stdc = yes; then
|
|
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <stdlib.h>
|
|
|
|
_ACEOF
|
|
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
|
|
$EGREP "free" >/dev/null 2>&1; then :
|
|
|
|
else
|
|
ac_cv_header_stdc=no
|
|
fi
|
|
rm -f conftest*
|
|
|
|
fi
|
|
|
|
if test $ac_cv_header_stdc = yes; then
|
|
# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
|
|
if test "$cross_compiling" = yes; then :
|
|
:
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#if ((' ' & 0x0FF) == 0x020)
|
|
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
|
|
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
|
|
#else
|
|
# define ISLOWER(c) \
|
|
(('a' <= (c) && (c) <= 'i') \
|
|
|| ('j' <= (c) && (c) <= 'r') \
|
|
|| ('s' <= (c) && (c) <= 'z'))
|
|
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
|
|
#endif
|
|
|
|
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
|
|
int
|
|
main ()
|
|
{
|
|
int i;
|
|
for (i = 0; i < 256; i++)
|
|
if (XOR (islower (i), ISLOWER (i))
|
|
|| toupper (i) != TOUPPER (i))
|
|
return 2;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_run "$LINENO"; then :
|
|
|
|
else
|
|
ac_cv_header_stdc=no
|
|
fi
|
|
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
|
|
conftest.$ac_objext conftest.beam conftest.$ac_ext
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
|
|
$as_echo "$ac_cv_header_stdc" >&6; }
|
|
if test $ac_cv_header_stdc = yes; then
|
|
|
|
$as_echo "#define STDC_HEADERS 1" >>confdefs.h
|
|
|
|
fi
|
|
|
|
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
|
|
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
|
|
inttypes.h stdint.h unistd.h
|
|
do :
|
|
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
|
|
ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
|
|
"
|
|
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
|
|
_ACEOF
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code.
|
|
# (The JVM can use 32 or 64 bit Java pointers but that decision
|
|
# is made at runtime.)
|
|
#
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
# Always specify -m flag on Solaris
|
|
# And -q on AIX because otherwise the compiler produces 32-bit objects by default
|
|
|
|
# When we add flags to the "official" CFLAGS etc, we need to
|
|
# keep track of these additions in ADDED_CFLAGS etc. These
|
|
# will later be checked to make sure only controlled additions
|
|
# have been made to CFLAGS etc.
|
|
ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
|
|
CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
|
|
LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
|
|
|
|
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
|
|
|
JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
|
|
JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
|
|
|
|
elif test "x$COMPILE_TYPE" = xreduced; then
|
|
if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
|
|
# Specify -m if running reduced on unix platforms
|
|
|
|
# When we add flags to the "official" CFLAGS etc, we need to
|
|
# keep track of these additions in ADDED_CFLAGS etc. These
|
|
# will later be checked to make sure only controlled additions
|
|
# have been made to CFLAGS etc.
|
|
ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
|
|
CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
|
|
LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
|
|
|
|
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
|
|
|
JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
|
|
JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
|
|
|
|
fi
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
JVM_CFLAGS="$JVM_CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
JVM_ASFLAGS="$JVM_ASFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
fi
|
|
|
|
# Make compilation sanity check
|
|
for ac_header in stdio.h
|
|
do :
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
|
|
if test "x$ac_cv_header_stdio_h" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_STDIO_H 1
|
|
_ACEOF
|
|
|
|
else
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Failed to compile stdio.h. This likely implies missing compile dependencies." >&5
|
|
$as_echo "$as_me: Failed to compile stdio.h. This likely implies missing compile dependencies." >&6;}
|
|
if test "x$COMPILE_TYPE" = xreduced; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# reduced is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=reduced
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&5
|
|
$as_echo "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&6;}
|
|
elif test "x$COMPILE_TYPE" = xcross; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
|
|
$as_echo "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot continue." "$LINENO" 5
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
# The cast to long int works around a bug in the HP C Compiler
|
|
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
|
|
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
|
|
# This bug is HP SR number 8606223364.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
|
|
$as_echo_n "checking size of int *... " >&6; }
|
|
if ${ac_cv_sizeof_int_p+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p" "$ac_includes_default"; then :
|
|
|
|
else
|
|
if test "$ac_cv_type_int_p" = yes; then
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error 77 "cannot compute sizeof (int *)
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
else
|
|
ac_cv_sizeof_int_p=0
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
|
|
$as_echo "$ac_cv_sizeof_int_p" >&6; }
|
|
|
|
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define SIZEOF_INT_P $ac_cv_sizeof_int_p
|
|
_ACEOF
|
|
|
|
|
|
|
|
# AC_CHECK_SIZEOF defines 'ac_cv_sizeof_int_p' to hold the number of bytes used by an 'int*'
|
|
if test "x$ac_cv_sizeof_int_p" = x; then
|
|
# The test failed, lets stick to the assumed value.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&5
|
|
$as_echo "$as_me: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&2;}
|
|
else
|
|
TESTED_TARGET_CPU_BITS=`expr 8 \* $ac_cv_sizeof_int_p`
|
|
|
|
if test "x$TESTED_TARGET_CPU_BITS" != "x$OPENJDK_TARGET_CPU_BITS"; then
|
|
# This situation may happen on 64-bit platforms where the compiler by default only generates 32-bit objects
|
|
# Let's try to implicitely set the compilers target architecture and retry the test
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&5
|
|
$as_echo "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Retrying with platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&5
|
|
$as_echo "$as_me: Retrying with platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&6;}
|
|
|
|
# When we add flags to the "official" CFLAGS etc, we need to
|
|
# keep track of these additions in ADDED_CFLAGS etc. These
|
|
# will later be checked to make sure only controlled additions
|
|
# have been made to CFLAGS etc.
|
|
ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
|
|
CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
|
|
LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
|
|
|
|
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
|
|
|
JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
|
|
JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
|
|
|
|
|
|
# We have to unset 'ac_cv_sizeof_int_p' first, otherwise AC_CHECK_SIZEOF will use the previously cached value!
|
|
unset ac_cv_sizeof_int_p
|
|
# And we have to undef the definition of SIZEOF_INT_P in confdefs.h by the previous invocation of AC_CHECK_SIZEOF
|
|
cat >>confdefs.h <<_ACEOF
|
|
#undef SIZEOF_INT_P
|
|
_ACEOF
|
|
|
|
# The cast to long int works around a bug in the HP C Compiler
|
|
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
|
|
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
|
|
# This bug is HP SR number 8606223364.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
|
|
$as_echo_n "checking size of int *... " >&6; }
|
|
if ${ac_cv_sizeof_int_p+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p" "$ac_includes_default"; then :
|
|
|
|
else
|
|
if test "$ac_cv_type_int_p" = yes; then
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
|
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
|
as_fn_error 77 "cannot compute sizeof (int *)
|
|
See \`config.log' for more details" "$LINENO" 5; }
|
|
else
|
|
ac_cv_sizeof_int_p=0
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
|
|
$as_echo "$ac_cv_sizeof_int_p" >&6; }
|
|
|
|
|
|
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define SIZEOF_INT_P $ac_cv_sizeof_int_p
|
|
_ACEOF
|
|
|
|
|
|
|
|
TESTED_TARGET_CPU_BITS=`expr 8 \* $ac_cv_sizeof_int_p`
|
|
|
|
if test "x$TESTED_TARGET_CPU_BITS" != "x$OPENJDK_TARGET_CPU_BITS"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)" >&5
|
|
$as_echo "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)" >&6;}
|
|
if test "x$COMPILE_TYPE" = xreduced; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# reduced is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=reduced
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&5
|
|
$as_echo "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed. $HELP_MSG" >&6;}
|
|
elif test "x$COMPILE_TYPE" = xcross; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
|
|
$as_echo "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
|
|
fi
|
|
as_fn_error $? "Cannot continue." "$LINENO" 5
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5
|
|
$as_echo_n "checking for target address size... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_CPU_BITS bits" >&5
|
|
$as_echo "$OPENJDK_TARGET_CPU_BITS bits" >&6; }
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Is the target little of big endian?
|
|
#
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
|
|
$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
|
|
if ${ac_cv_c_bigendian+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_cv_c_bigendian=unknown
|
|
# See if we're dealing with a universal compiler.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#ifndef __APPLE_CC__
|
|
not a universal capable compiler
|
|
#endif
|
|
typedef int dummy;
|
|
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
# Check for potential -arch flags. It is not universal unless
|
|
# there are at least two -arch flags with different values.
|
|
ac_arch=
|
|
ac_prev=
|
|
for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
|
|
if test -n "$ac_prev"; then
|
|
case $ac_word in
|
|
i?86 | x86_64 | ppc | ppc64)
|
|
if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
|
|
ac_arch=$ac_word
|
|
else
|
|
ac_cv_c_bigendian=universal
|
|
break
|
|
fi
|
|
;;
|
|
esac
|
|
ac_prev=
|
|
elif test "x$ac_word" = "x-arch"; then
|
|
ac_prev=arch
|
|
fi
|
|
done
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
if test $ac_cv_c_bigendian = unknown; then
|
|
# See if sys/param.h defines the BYTE_ORDER macro.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
|
|
int
|
|
main ()
|
|
{
|
|
#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
|
|
&& defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
|
|
&& LITTLE_ENDIAN)
|
|
bogus endian macros
|
|
#endif
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
# It does; now see whether it defined to BIG_ENDIAN or not.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
|
|
int
|
|
main ()
|
|
{
|
|
#if BYTE_ORDER != BIG_ENDIAN
|
|
not big endian
|
|
#endif
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_cv_c_bigendian=yes
|
|
else
|
|
ac_cv_c_bigendian=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
if test $ac_cv_c_bigendian = unknown; then
|
|
# See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <limits.h>
|
|
|
|
int
|
|
main ()
|
|
{
|
|
#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
|
|
bogus endian macros
|
|
#endif
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
# It does; now see whether it defined to _BIG_ENDIAN or not.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <limits.h>
|
|
|
|
int
|
|
main ()
|
|
{
|
|
#ifndef _BIG_ENDIAN
|
|
not big endian
|
|
#endif
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
ac_cv_c_bigendian=yes
|
|
else
|
|
ac_cv_c_bigendian=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
fi
|
|
if test $ac_cv_c_bigendian = unknown; then
|
|
# Compile a test program.
|
|
if test "$cross_compiling" = yes; then :
|
|
# Try to guess by grepping values from an object file.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
short int ascii_mm[] =
|
|
{ 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
|
|
short int ascii_ii[] =
|
|
{ 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
|
|
int use_ascii (int i) {
|
|
return ascii_mm[i] + ascii_ii[i];
|
|
}
|
|
short int ebcdic_ii[] =
|
|
{ 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
|
|
short int ebcdic_mm[] =
|
|
{ 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
|
|
int use_ebcdic (int i) {
|
|
return ebcdic_mm[i] + ebcdic_ii[i];
|
|
}
|
|
extern int foo;
|
|
|
|
int
|
|
main ()
|
|
{
|
|
return use_ascii (foo) == use_ebcdic (foo);
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
|
|
ac_cv_c_bigendian=yes
|
|
fi
|
|
if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
|
|
if test "$ac_cv_c_bigendian" = unknown; then
|
|
ac_cv_c_bigendian=no
|
|
else
|
|
# finding both strings is unlikely to happen, but who knows?
|
|
ac_cv_c_bigendian=unknown
|
|
fi
|
|
fi
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
else
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
$ac_includes_default
|
|
int
|
|
main ()
|
|
{
|
|
|
|
/* Are we little or big endian? From Harbison&Steele. */
|
|
union
|
|
{
|
|
long int l;
|
|
char c[sizeof (long int)];
|
|
} u;
|
|
u.l = 1;
|
|
return u.c[sizeof (long int) - 1] == 1;
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_run "$LINENO"; then :
|
|
ac_cv_c_bigendian=no
|
|
else
|
|
ac_cv_c_bigendian=yes
|
|
fi
|
|
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
|
|
conftest.$ac_objext conftest.beam conftest.$ac_ext
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
|
|
$as_echo "$ac_cv_c_bigendian" >&6; }
|
|
case $ac_cv_c_bigendian in #(
|
|
yes)
|
|
ENDIAN="big";; #(
|
|
no)
|
|
ENDIAN="little" ;; #(
|
|
universal)
|
|
ENDIAN="universal_endianness"
|
|
;; #(
|
|
*)
|
|
ENDIAN="unknown" ;;
|
|
esac
|
|
|
|
|
|
if test "x$ENDIAN" = xuniversal_endianness; then
|
|
as_fn_error $? "Building with both big and little endianness is not supported" "$LINENO" 5
|
|
fi
|
|
if test "x$ENDIAN" != "x$OPENJDK_TARGET_CPU_ENDIAN"; then
|
|
as_fn_error $? "The tested endian in the target ($ENDIAN) differs from the endian expected to be found in the target ($OPENJDK_TARGET_CPU_ENDIAN)" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
# Configure flags for the tools
|
|
|
|
###############################################################################
|
|
#
|
|
# How to compile shared libraries.
|
|
#
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
PICFLAG="-fPIC"
|
|
C_FLAG_REORDER=''
|
|
CXX_FLAG_REORDER=''
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# Linking is different on MacOSX
|
|
if test "x$STATIC_BUILD" = xtrue; then
|
|
SHARED_LIBRARY_FLAGS ='-undefined dynamic_lookup'
|
|
else
|
|
SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
|
|
JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
|
|
fi
|
|
SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or $1,/.)'
|
|
SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
|
|
SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/$1'
|
|
SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,$1'
|
|
else
|
|
# Default works for linux, might work on other platforms as well.
|
|
SHARED_LIBRARY_FLAGS='-shared'
|
|
SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN$1'
|
|
SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
|
|
SET_SHARED_LIBRARY_NAME='-Wl,-soname=$1'
|
|
SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=$1'
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
C_FLAG_REORDER=''
|
|
CXX_FLAG_REORDER=''
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# Linking is different on MacOSX
|
|
PICFLAG=''
|
|
SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
|
|
SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or $1,/.)'
|
|
SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
|
|
SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/$1'
|
|
SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,$1'
|
|
|
|
if test "x$STATIC_BUILD" = xfalse; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -fPIC"
|
|
fi
|
|
else
|
|
# Default works for linux, might work on other platforms as well.
|
|
PICFLAG='-fPIC'
|
|
SHARED_LIBRARY_FLAGS='-shared'
|
|
SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN$1'
|
|
SET_SHARED_LIBRARY_NAME='-Wl,-soname=$1'
|
|
SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=$1'
|
|
|
|
# arm specific settings
|
|
if test "x$OPENJDK_TARGET_CPU" = "xarm"; then
|
|
# '-Wl,-z,origin' isn't used on arm.
|
|
SET_SHARED_LIBRARY_ORIGIN='-Wl,-rpath,\$$$$ORIGIN$1'
|
|
else
|
|
SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
|
|
fi
|
|
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
if test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
|
|
PICFLAG="-xcode=pic32"
|
|
else
|
|
PICFLAG="-KPIC"
|
|
fi
|
|
C_FLAG_REORDER='-xF'
|
|
CXX_FLAG_REORDER='-xF'
|
|
SHARED_LIBRARY_FLAGS="-G"
|
|
SET_EXECUTABLE_ORIGIN='-R\$$ORIGIN$1'
|
|
SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
|
|
SET_SHARED_LIBRARY_NAME='-h $1'
|
|
SET_SHARED_LIBRARY_MAPFILE='-M$1'
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
# '-qpic' defaults to 'qpic=small'. This means that the compiler generates only
|
|
# one instruction for accessing the TOC. If the TOC grows larger than 64K, the linker
|
|
# will have to patch this single instruction with a call to some out-of-order code which
|
|
# does the load from the TOC. This is of course slow. But in that case we also would have
|
|
# to use '-bbigtoc' for linking anyway so we could also change the PICFLAG to 'qpic=large'.
|
|
# With 'qpic=large' the compiler will by default generate a two-instruction sequence which
|
|
# can be patched directly by the linker and does not require a jump to out-of-order code.
|
|
# Another alternative instead of using 'qpic=large -bbigtoc' may be to use '-qminimaltoc'
|
|
# instead. This creates a distinct TOC for every compilation unit (and thus requires two
|
|
# loads for accessing a global variable). But there are rumors that this may be seen as a
|
|
# 'performance feature' because of improved code locality of the symbols used in a
|
|
# compilation unit.
|
|
PICFLAG="-qpic"
|
|
JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
|
|
C_FLAG_REORDER=''
|
|
CXX_FLAG_REORDER=''
|
|
SHARED_LIBRARY_FLAGS="-qmkshrobj -bM:SRE -bnoentry"
|
|
SET_EXECUTABLE_ORIGIN=""
|
|
SET_SHARED_LIBRARY_ORIGIN=''
|
|
SET_SHARED_LIBRARY_NAME=''
|
|
SET_SHARED_LIBRARY_MAPFILE=''
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
PICFLAG=""
|
|
C_FLAG_REORDER=''
|
|
CXX_FLAG_REORDER=''
|
|
SHARED_LIBRARY_FLAGS="-dll"
|
|
SET_EXECUTABLE_ORIGIN=''
|
|
SET_SHARED_LIBRARY_ORIGIN=''
|
|
SET_SHARED_LIBRARY_NAME=''
|
|
SET_SHARED_LIBRARY_MAPFILE='-def:$1'
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# The (cross) compiler is now configured, we can now test capabilities
|
|
# of the target platform.
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Setup the opt flags for different compilers
|
|
# and different operating systems.
|
|
#
|
|
|
|
# FIXME: this was indirectly the old default, but just inherited.
|
|
# if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
# C_FLAG_DEPS="-MMD -MF"
|
|
# fi
|
|
|
|
# Generate make dependency files
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
C_FLAG_DEPS="-MMD -MF"
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
C_FLAG_DEPS="-MMD -MF"
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
C_FLAG_DEPS="-xMMD -xMF"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
C_FLAG_DEPS="-qmakedep=gcc -MF"
|
|
fi
|
|
CXX_FLAG_DEPS="$C_FLAG_DEPS"
|
|
|
|
|
|
|
|
# Debug symbols
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
|
|
# reduce from default "-g2" option to save space
|
|
CFLAGS_DEBUG_SYMBOLS="-g1"
|
|
CXXFLAGS_DEBUG_SYMBOLS="-g1"
|
|
else
|
|
CFLAGS_DEBUG_SYMBOLS="-g"
|
|
CXXFLAGS_DEBUG_SYMBOLS="-g"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
CFLAGS_DEBUG_SYMBOLS="-g"
|
|
CXXFLAGS_DEBUG_SYMBOLS="-g"
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
CFLAGS_DEBUG_SYMBOLS="-g -xs"
|
|
# -g0 enables debug symbols without disabling inlining.
|
|
CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
CFLAGS_DEBUG_SYMBOLS="-g"
|
|
CXXFLAGS_DEBUG_SYMBOLS="-g"
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
CFLAGS_DEBUG_SYMBOLS="-Zi"
|
|
CXXFLAGS_DEBUG_SYMBOLS="-Zi"
|
|
fi
|
|
|
|
|
|
|
|
# Debug symbols for JVM_CFLAGS
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -xs"
|
|
if test "x$DEBUG_LEVEL" = xslowdebug; then
|
|
JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"
|
|
else
|
|
# -g0 does not disable inlining, which -g does.
|
|
JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g0"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -Z7 -d2Zi+"
|
|
else
|
|
JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -g"
|
|
fi
|
|
|
|
|
|
# bounds, memory and behavior checking options
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
case $DEBUG_LEVEL in
|
|
release )
|
|
# no adjustment
|
|
;;
|
|
fastdebug )
|
|
# no adjustment
|
|
;;
|
|
slowdebug )
|
|
# FIXME: By adding this to C(XX)FLAGS_DEBUG_OPTIONS/JVM_CFLAGS_SYMBOLS it
|
|
# get's added conditionally on whether we produce debug symbols or not.
|
|
# This is most likely not really correct.
|
|
|
|
# Add runtime stack smashing and undefined behavior checks.
|
|
# Not all versions of gcc support -fstack-protector
|
|
STACK_PROTECTOR_CFLAG="-fstack-protector-all"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"" >&5
|
|
$as_echo_n "checking if the C compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cflags="$CFLAGS"
|
|
CFLAGS="$CFLAGS $STACK_PROTECTOR_CFLAG -Werror"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CFLAGS="$saved_cflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
C_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
C_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"$STACK_PROTECTOR_CFLAG -Werror\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG $STACK_PROTECTOR_CFLAG -Werror"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
CXX_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
CXX_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$STACK_PROTECTOR_CFLAG -Werror\"" >&5
|
|
$as_echo_n "checking if both compilers support \"$STACK_PROTECTOR_CFLAG -Werror\"... " >&6; }
|
|
supports=no
|
|
if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
|
|
else
|
|
:
|
|
STACK_PROTECTOR_CFLAG=""
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
|
|
CXXFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
|
|
if test "x$STACK_PROTECTOR_CFLAG" != x; then
|
|
JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS $STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
if test "x$DEBUG_LEVEL" != xrelease; then
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -homeparams"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Optimization levels
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
|
|
# FIXME: seems we always set -xregs=no%frameptr; put it elsewhere more global?
|
|
C_O_FLAG_HIGHEST_JVM="-xO4"
|
|
C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
|
|
C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
|
|
C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
|
|
C_O_FLAG_DEBUG="-xregs=no%frameptr"
|
|
C_O_FLAG_DEBUG_JVM=""
|
|
C_O_FLAG_NONE="-xregs=no%frameptr"
|
|
CXX_O_FLAG_HIGHEST_JVM="-xO4"
|
|
CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
|
|
CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
|
|
CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
|
|
CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
|
|
CXX_O_FLAG_DEBUG_JVM=""
|
|
CXX_O_FLAG_NONE="-xregs=no%frameptr"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
|
|
C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
|
|
CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
|
|
C_O_FLAG_HIGHEST_JVM="-xO4"
|
|
C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
|
|
C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
|
|
C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
|
|
C_O_FLAG_DEBUG=""
|
|
C_O_FLAG_DEBUG_JVM=""
|
|
C_O_FLAG_NONE=""
|
|
CXX_O_FLAG_HIGHEST_JVM="-xO4"
|
|
CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
|
|
CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
|
|
CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
|
|
CXX_O_FLAG_DEBUG=""
|
|
CXX_O_FLAG_DEBUG_JVM=""
|
|
CXX_O_FLAG_NONE=""
|
|
fi
|
|
else
|
|
# The remaining toolchains share opt flags between CC and CXX;
|
|
# setup for C and duplicate afterwards.
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# On MacOSX we optimize for size, something
|
|
# we should do for all platforms?
|
|
C_O_FLAG_HIGHEST_JVM="-Os"
|
|
C_O_FLAG_HIGHEST="-Os"
|
|
C_O_FLAG_HI="-Os"
|
|
C_O_FLAG_NORM="-Os"
|
|
C_O_FLAG_SIZE="-Os"
|
|
else
|
|
C_O_FLAG_HIGHEST_JVM="-O3"
|
|
C_O_FLAG_HIGHEST="-O3"
|
|
C_O_FLAG_HI="-O3"
|
|
C_O_FLAG_NORM="-O2"
|
|
C_O_FLAG_SIZE="-Os"
|
|
fi
|
|
C_O_FLAG_DEBUG="-O0"
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
C_O_FLAG_DEBUG_JVM=""
|
|
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
C_O_FLAG_DEBUG_JVM="-O0"
|
|
fi
|
|
C_O_FLAG_NONE="-O0"
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# On MacOSX we optimize for size, something
|
|
# we should do for all platforms?
|
|
C_O_FLAG_HIGHEST_JVM="-Os"
|
|
C_O_FLAG_HIGHEST="-Os"
|
|
C_O_FLAG_HI="-Os"
|
|
C_O_FLAG_NORM="-Os"
|
|
C_O_FLAG_SIZE="-Os"
|
|
else
|
|
C_O_FLAG_HIGHEST_JVM="-O3"
|
|
C_O_FLAG_HIGHEST="-O3"
|
|
C_O_FLAG_HI="-O3"
|
|
C_O_FLAG_NORM="-O2"
|
|
C_O_FLAG_SIZE="-Os"
|
|
fi
|
|
C_O_FLAG_DEBUG="-O0"
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
C_O_FLAG_DEBUG_JVM=""
|
|
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
C_O_FLAG_DEBUG_JVM="-O0"
|
|
fi
|
|
C_O_FLAG_NONE="-O0"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
C_O_FLAG_HIGHEST_JVM="-O3 -qhot=level=1 -qinline -qinlglue"
|
|
C_O_FLAG_HIGHEST="-O3 -qhot=level=1 -qinline -qinlglue"
|
|
C_O_FLAG_HI="-O3 -qinline -qinlglue"
|
|
C_O_FLAG_NORM="-O2"
|
|
C_O_FLAG_DEBUG="-qnoopt"
|
|
# FIXME: Value below not verified.
|
|
C_O_FLAG_DEBUG_JVM=""
|
|
C_O_FLAG_NONE="-qnoopt"
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
C_O_FLAG_HIGHEST_JVM="-O2 -Oy-"
|
|
C_O_FLAG_HIGHEST="-O2"
|
|
C_O_FLAG_HI="-O1"
|
|
C_O_FLAG_NORM="-O1"
|
|
C_O_FLAG_DEBUG="-Od"
|
|
C_O_FLAG_DEBUG_JVM=""
|
|
C_O_FLAG_NONE="-Od"
|
|
C_O_FLAG_SIZE="-Os"
|
|
fi
|
|
CXX_O_FLAG_HIGHEST_JVM="$C_O_FLAG_HIGHEST_JVM"
|
|
CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
|
|
CXX_O_FLAG_HI="$C_O_FLAG_HI"
|
|
CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
|
|
CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
|
|
CXX_O_FLAG_DEBUG_JVM="$C_O_FLAG_DEBUG_JVM"
|
|
CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
|
|
CXX_O_FLAG_SIZE="$C_O_FLAG_SIZE"
|
|
fi
|
|
|
|
# Adjust optimization flags according to debug level.
|
|
case $DEBUG_LEVEL in
|
|
release )
|
|
# no adjustment
|
|
;;
|
|
fastdebug )
|
|
# Not quite so much optimization
|
|
C_O_FLAG_HI="$C_O_FLAG_NORM"
|
|
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
|
|
;;
|
|
slowdebug )
|
|
# Disable optimization
|
|
C_O_FLAG_HIGHEST_JVM="$C_O_FLAG_DEBUG_JVM"
|
|
C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
|
|
C_O_FLAG_HI="$C_O_FLAG_DEBUG"
|
|
C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
|
|
C_O_FLAG_SIZE="$C_O_FLAG_DEBUG"
|
|
CXX_O_FLAG_HIGHEST_JVM="$CXX_O_FLAG_DEBUG_JVM"
|
|
CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
|
|
CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
|
|
CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
|
|
CXX_O_FLAG_SIZE="$CXX_O_FLAG_DEBUG"
|
|
;;
|
|
esac
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-abi-profile was given.
|
|
if test "${with_abi_profile+set}" = set; then :
|
|
withval=$with_abi_profile;
|
|
fi
|
|
|
|
|
|
if test "x$with_abi_profile" != x; then
|
|
if test "x$OPENJDK_TARGET_CPU" != xarm && \
|
|
test "x$OPENJDK_TARGET_CPU" != xaarch64; then
|
|
as_fn_error $? "--with-abi-profile only available on arm/aarch64" "$LINENO" 5
|
|
fi
|
|
|
|
OPENJDK_TARGET_ABI_PROFILE=$with_abi_profile
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ABI profle" >&5
|
|
$as_echo_n "checking for ABI profle... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_ABI_PROFILE" >&5
|
|
$as_echo "$OPENJDK_TARGET_ABI_PROFILE" >&6; }
|
|
|
|
if test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-vfp-sflt; then
|
|
ARM_FLOAT_TYPE=vfp-sflt
|
|
ARM_ARCH_TYPE_FLAGS='-march=armv7-a -mthumb'
|
|
elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-vfp-hflt; then
|
|
ARM_FLOAT_TYPE=vfp-hflt
|
|
ARM_ARCH_TYPE_FLAGS='-march=armv7-a -mthumb'
|
|
elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm-sflt; then
|
|
ARM_FLOAT_TYPE=sflt
|
|
ARM_ARCH_TYPE_FLAGS='-march=armv5t -marm'
|
|
elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarmv5-vfp-sflt; then
|
|
ARM_FLOAT_TYPE=vfp-sflt
|
|
ARM_ARCH_TYPE_FLAGS='-march=armv5t -marm'
|
|
elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarmv6-vfp-hflt; then
|
|
ARM_FLOAT_TYPE=vfp-hflt
|
|
ARM_ARCH_TYPE_FLAGS='-march=armv6 -marm'
|
|
elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xarm64; then
|
|
# No special flags, just need to trigger setting JDK_ARCH_ABI_PROP_NAME
|
|
ARM_FLOAT_TYPE=
|
|
ARM_ARCH_TYPE_FLAGS=
|
|
elif test "x$OPENJDK_TARGET_ABI_PROFILE" = xaarch64; then
|
|
# No special flags, just need to trigger setting JDK_ARCH_ABI_PROP_NAME
|
|
ARM_FLOAT_TYPE=
|
|
ARM_ARCH_TYPE_FLAGS=
|
|
else
|
|
as_fn_error $? "Invalid ABI profile: \"$OPENJDK_TARGET_ABI_PROFILE\"" "$LINENO" 5
|
|
fi
|
|
|
|
if test "x$ARM_FLOAT_TYPE" = xvfp-sflt; then
|
|
ARM_FLOAT_TYPE_FLAGS='-mfloat-abi=softfp -mfpu=vfp -DFLOAT_ARCH=-vfp-sflt'
|
|
elif test "x$ARM_FLOAT_TYPE" = xvfp-hflt; then
|
|
ARM_FLOAT_TYPE_FLAGS='-mfloat-abi=hard -mfpu=vfp -DFLOAT_ARCH=-vfp-hflt'
|
|
elif test "x$ARM_FLOAT_TYPE" = xsflt; then
|
|
ARM_FLOAT_TYPE_FLAGS='-msoft-float -mfpu=vfp'
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ARM_FLOAT_TYPE floating point flags" >&5
|
|
$as_echo_n "checking for $ARM_FLOAT_TYPE floating point flags... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ARM_FLOAT_TYPE_FLAGS" >&5
|
|
$as_echo "$ARM_FLOAT_TYPE_FLAGS" >&6; }
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for arch type flags" >&5
|
|
$as_echo_n "checking for arch type flags... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ARM_ARCH_TYPE_FLAGS" >&5
|
|
$as_echo "$ARM_ARCH_TYPE_FLAGS" >&6; }
|
|
|
|
# Now set JDK_ARCH_ABI_PROP_NAME. This is equivalent to the last part of the
|
|
# autoconf target triplet.
|
|
JDK_ARCH_ABI_PROP_NAME=`$ECHO $OPENJDK_TARGET_AUTOCONF_NAME | $SED -e 's/.*-\([^-]*\)$/\1/'`
|
|
# Sanity check that it is a known ABI.
|
|
if test "x$JDK_ARCH_ABI_PROP_NAME" != xgnu && \
|
|
test "x$JDK_ARCH_ABI_PROP_NAME" != xgnueabi && \
|
|
test "x$JDK_ARCH_ABI_PROP_NAME" != xgnueabihf; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unknown autoconf target triplet ABI: \"$JDK_ARCH_ABI_PROP_NAME\"" >&5
|
|
$as_echo "$as_me: WARNING: Unknown autoconf target triplet ABI: \"$JDK_ARCH_ABI_PROP_NAME\"" >&2;}
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ABI property name" >&5
|
|
$as_echo_n "checking for ABI property name... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_ARCH_ABI_PROP_NAME" >&5
|
|
$as_echo "$JDK_ARCH_ABI_PROP_NAME" >&6; }
|
|
|
|
|
|
# Pass these on to the open part of configure as if they were set using
|
|
# --with-extra-c[xx]flags.
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"
|
|
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"
|
|
# Get rid of annoying "note: the mangling of 'va_list' has changed in GCC 4.4"
|
|
# FIXME: This should not really be set using extra_cflags.
|
|
if test "x$OPENJDK_TARGET_CPU" = xarm; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -Wno-psabi"
|
|
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -Wno-psabi"
|
|
fi
|
|
# Also add JDK_ARCH_ABI_PROP_NAME define, but only to CFLAGS.
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DJDK_ARCH_ABI_PROP_NAME='\"\$(JDK_ARCH_ABI_PROP_NAME)\"'"
|
|
# And pass the architecture flags to the linker as well
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ARM_ARCH_TYPE_FLAGS $ARM_FLOAT_TYPE_FLAGS"
|
|
fi
|
|
|
|
# When building with an abi profile, the name of that profile is appended on the
|
|
# bundle platform, which is used in bundle names.
|
|
if test "x$OPENJDK_TARGET_ABI_PROFILE" != x; then
|
|
OPENJDK_TARGET_BUNDLE_PLATFORM="$OPENJDK_TARGET_OS_BUNDLE-$OPENJDK_TARGET_ABI_PROFILE"
|
|
fi
|
|
|
|
|
|
# Optional POSIX functionality needed by the JVM
|
|
#
|
|
# Check if clock_gettime is available and in which library. This indicates
|
|
# availability of CLOCK_MONOTONIC for hotspot. But we don't need to link, so
|
|
# don't let it update LIBS.
|
|
save_LIBS="$LIBS"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
|
|
$as_echo_n "checking for library containing clock_gettime... " >&6; }
|
|
if ${ac_cv_search_clock_gettime+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_func_search_save_LIBS=$LIBS
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char clock_gettime ();
|
|
int
|
|
main ()
|
|
{
|
|
return clock_gettime ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
for ac_lib in '' rt; do
|
|
if test -z "$ac_lib"; then
|
|
ac_res="none required"
|
|
else
|
|
ac_res=-l$ac_lib
|
|
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
|
|
fi
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_search_clock_gettime=$ac_res
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext
|
|
if ${ac_cv_search_clock_gettime+:} false; then :
|
|
break
|
|
fi
|
|
done
|
|
if ${ac_cv_search_clock_gettime+:} false; then :
|
|
|
|
else
|
|
ac_cv_search_clock_gettime=no
|
|
fi
|
|
rm conftest.$ac_ext
|
|
LIBS=$ac_func_search_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5
|
|
$as_echo "$ac_cv_search_clock_gettime" >&6; }
|
|
ac_res=$ac_cv_search_clock_gettime
|
|
if test "$ac_res" != no; then :
|
|
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
|
|
HAS_CLOCK_GETTIME=true
|
|
fi
|
|
|
|
if test "x$LIBS" = "x-lrt "; then
|
|
CLOCK_GETTIME_IN_LIBRT=true
|
|
fi
|
|
LIBS="$save_LIBS"
|
|
|
|
|
|
# Special extras...
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
if test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
|
|
CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
|
|
CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
|
|
fi
|
|
CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
|
|
CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
CFLAGS_JDK="${CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
CXXSTD_CXXFLAG="-std=gnu++98"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG $CXXSTD_CXXFLAG -Werror"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
|
|
else
|
|
:
|
|
CXXSTD_CXXFLAG=""
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK} ${CXXSTD_CXXFLAG}"
|
|
JVM_CFLAGS="${JVM_CFLAGS} ${CXXSTD_CXXFLAG}"
|
|
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__"
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__"
|
|
fi
|
|
|
|
CFLAGS_JDK="${CFLAGS_JDK} ${EXTRA_CFLAGS}"
|
|
CXXFLAGS_JDK="${CXXFLAGS_JDK} ${EXTRA_CXXFLAGS}"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK} ${EXTRA_LDFLAGS}"
|
|
|
|
###############################################################################
|
|
#
|
|
# Now setup the CFLAGS and LDFLAGS for the JDK build.
|
|
# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
|
|
#
|
|
|
|
# Setup compiler/platform specific flags into
|
|
# CFLAGS_JDK - C Compiler flags
|
|
# CXXFLAGS_JDK - C++ Compiler flags
|
|
# COMMON_CCXXFLAGS_JDK - common to C and C++
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_GNU_SOURCE"
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_REENTRANT"
|
|
JVM_CFLAGS="$JVM_CFLAGS -fcheck-new"
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
# Force compatibility with i586 on 32 bit intel platforms.
|
|
COMMON_CCXXFLAGS="${COMMON_CCXXFLAGS} -march=i586"
|
|
JVM_CFLAGS="$JVM_CFLAGS -march=i586"
|
|
fi
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
|
|
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
|
|
case $OPENJDK_TARGET_CPU_ARCH in
|
|
arm )
|
|
# on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
|
|
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
|
|
COMMON_CCXXFLAGS_JDK="${COMMON_CCXXFLAGS_JDK} -fsigned-char"
|
|
;;
|
|
ppc )
|
|
# on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
|
|
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
s390 )
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer -mbackchain -march=z10"
|
|
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
* )
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
|
|
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
esac
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
# Need to assign to a variable since m4 is blocked from modifying parts in [].
|
|
REFERENCE_VERSION=6
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ (.*\.){4} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 6, only four parts (W.X.Y.Z) is supported" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 6, only parts < 99999 is supported" "$LINENO" 5
|
|
fi
|
|
|
|
# Version comparison method inspired by http://stackoverflow.com/a/24067243
|
|
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$REFERENCE_VERSION"`
|
|
|
|
if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
|
|
:
|
|
|
|
# These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
|
|
# runs afoul of the more aggressive versions of these optimisations.
|
|
# Notably, value range propagation now assumes that the this pointer of C++
|
|
# member functions is non-null.
|
|
NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
|
|
NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&5
|
|
$as_echo "$as_me: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&6;}
|
|
CFLAGS_JDK="$CFLAGS_JDK ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
|
|
JVM_CFLAGS="$JVM_CFLAGS ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
|
|
|
|
else
|
|
:
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_GNU_SOURCE"
|
|
|
|
# Restrict the debug information created by Clang to avoid
|
|
# too big object files and speed the build up a little bit
|
|
# (see http://llvm.org/bugs/show_bug.cgi?id=7554)
|
|
JVM_CFLAGS="$JVM_CFLAGS -flimit-debug-info"
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
# Force compatibility with i586 on 32 bit intel platforms.
|
|
COMMON_CCXXFLAGS="${COMMON_CCXXFLAGS} -march=i586"
|
|
JVM_CFLAGS="$JVM_CFLAGS -march=i586"
|
|
fi
|
|
JVM_CFLAGS="$JVM_CFLAGS -Wno-sometimes-uninitialized"
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
|
|
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
|
|
case $OPENJDK_TARGET_CPU_ARCH in
|
|
ppc )
|
|
# on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
|
|
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
* )
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
|
|
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
esac
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DSPARC_WORKS"
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
|
|
if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
|
|
fi
|
|
|
|
CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
|
|
CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_REENTRANT"
|
|
CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
|
|
CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK \
|
|
-MD -Zc:wchar_t- -W3 -wd4800 \
|
|
-DWIN32_LEAN_AND_MEAN \
|
|
-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
|
|
-D_WINSOCK_DEPRECATED_NO_WARNINGS \
|
|
-DWIN32 -DIAL"
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
|
|
else
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
|
|
fi
|
|
# If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
|
|
# avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual
|
|
# studio.
|
|
if test "x$TOOLCHAIN_VERSION" = "x2010"; then
|
|
STATIC_CPPLIB_FLAGS="-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB"
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $STATIC_CPPLIB_FLAGS"
|
|
JVM_CFLAGS="$JVM_CFLAGS $STATIC_CPPLIB_FLAGS"
|
|
fi
|
|
fi
|
|
|
|
###############################################################################
|
|
|
|
# Adjust flags according to debug level.
|
|
case $DEBUG_LEVEL in
|
|
fastdebug | slowdebug )
|
|
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
|
|
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
|
|
;;
|
|
release )
|
|
;;
|
|
* )
|
|
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
|
|
;;
|
|
esac
|
|
|
|
# Set some common defines. These works for all compilers, but assume
|
|
# -D is universally accepted.
|
|
|
|
# Setup endianness
|
|
if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
|
|
# The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
|
|
# Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
|
|
# (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
|
|
# Note: -Dmacro is the same as #define macro 1
|
|
# -Dmacro= is the same as #define macro
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
|
|
else
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
|
|
fi
|
|
else
|
|
# Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
|
|
# are defined in the system?
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
|
|
else
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
|
|
fi
|
|
fi
|
|
|
|
# Always enable optional macros for VM.
|
|
JVM_CFLAGS="$JVM_CFLAGS -D__STDC_FORMAT_MACROS"
|
|
JVM_CFLAGS="$JVM_CFLAGS -D__STDC_LIMIT_MACROS"
|
|
JVM_CFLAGS="$JVM_CFLAGS -D__STDC_CONSTANT_MACROS"
|
|
|
|
# Setup target OS define. Use OS target name but in upper case.
|
|
OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
|
|
|
|
# Setup target CPU
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
|
|
$OPENJDK_TARGET_ADD_LP64 \
|
|
-DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
|
|
|
|
# Setup debug/release defines
|
|
if test "x$DEBUG_LEVEL" = xrelease; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
|
|
fi
|
|
else
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
|
|
fi
|
|
|
|
# Optional POSIX functionality needed by the VM
|
|
|
|
if test "x$HAS_CLOCK_GETTIME" = "xtrue"; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DSUPPORTS_CLOCK_MONOTONIC"
|
|
if test "x$CLOCK_GETTIME_IN_LIBRT" = "xtrue"; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DNEEDS_LIBRT"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Set some additional per-OS defines.
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DLINUX"
|
|
JVM_CFLAGS="$JVM_CFLAGS -pipe $PICFLAG -fno-rtti -fno-exceptions \
|
|
-fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DSOLARIS"
|
|
JVM_CFLAGS="$JVM_CFLAGS -template=no%extdef -features=no%split_init \
|
|
-D_Crun_inline_placement -library=stlport4 $PICFLAG -mt -features=no%except"
|
|
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_ALLBSD_SOURCE"
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
|
|
JVM_CFLAGS="$JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
|
|
-mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
|
|
-fno-omit-frame-pointer"
|
|
elif test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DAIX"
|
|
JVM_CFLAGS="$JVM_CFLAGS -qtune=balanced \
|
|
-qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
|
|
-qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
|
|
# We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
|
|
# Hotspot now overflows its 64K TOC (currently only for slowdebug),
|
|
# so for slowdebug we build with '-qpic=large -bbigtoc'.
|
|
if test "x$DEBUG_LEVEL" = xslowdebug; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -qpic=large"
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xbsd; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
|
|
elif test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
|
|
JVM_CFLAGS="$JVM_CFLAGS -nologo -W3 -MD -MP"
|
|
fi
|
|
|
|
# Set some additional per-CPU defines.
|
|
if test "x$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" = xwindows-x86; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -arch:IA32"
|
|
elif test "x$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" = xsolaris-sparcv9; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -xarch=sparc"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc64; then
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
|
|
# fixes `relocation truncated to fit' error for gcc 4.1.
|
|
JVM_CFLAGS="$JVM_CFLAGS -mminimal-toc"
|
|
# Use ppc64 instructions, but schedule for power5
|
|
JVM_CFLAGS="$JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
|
|
elif test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -qarch=ppc64"
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_CPU" = xppc64le; then
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
|
|
# Little endian machine uses ELFv2 ABI.
|
|
JVM_CFLAGS="$JVM_CFLAGS -DABI_ELFv2"
|
|
# Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
|
|
JVM_CFLAGS="$JVM_CFLAGS -mcpu=power8 -mtune=power8"
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_CPU" = xs390x; then
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -mbackchain -march=z10"
|
|
fi
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -DVM_LITTLE_ENDIAN"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
if test "x$OPENJDK_TARGET_OS" != xsolaris && test "x$OPENJDK_TARGET_OS" != xaix; then
|
|
# Solaris does not have _LP64=1 in the old build.
|
|
# xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
|
|
JVM_CFLAGS="$JVM_CFLAGS -D_LP64=1"
|
|
fi
|
|
fi
|
|
|
|
# Set JVM_CFLAGS warning handling
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
|
|
-Wunused-value -Woverloaded-virtual"
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
# Need to assign to a variable since m4 is blocked from modifying parts in [].
|
|
REFERENCE_VERSION=4.8
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ (.*\.){4} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 4.8, only four parts (W.X.Y.Z) is supported" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 4.8, only parts < 99999 is supported" "$LINENO" 5
|
|
fi
|
|
|
|
# Version comparison method inspired by http://stackoverflow.com/a/24067243
|
|
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$REFERENCE_VERSION"`
|
|
|
|
if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
|
|
:
|
|
|
|
# These flags either do not work or give spurious warnings prior to gcc 4.8.
|
|
JVM_CFLAGS="$JVM_CFLAGS -Wno-format-zero-length -Wtype-limits -Wuninitialized"
|
|
|
|
|
|
else
|
|
:
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fi
|
|
if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
# Non-zero builds have stricter warnings
|
|
JVM_CFLAGS="$JVM_CFLAGS -Wreturn-type -Wundef -Wformat=2"
|
|
else
|
|
if test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
# Some versions of llvm do not like -Wundef
|
|
JVM_CFLAGS="$JVM_CFLAGS -Wno-undef"
|
|
fi
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
JVM_CFLAGS="$JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
|
|
-Wsign-compare -Wundef -Wunused-function -Wformat=2"
|
|
fi
|
|
|
|
# Additional macosx handling
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# MACOSX_VERSION_MIN is the c++ and ld is -mmacosx-version-min argument. The expected
|
|
# format is X.Y.Z. It's hard-coded to the minimum OSX version on which the
|
|
# JDK can be built and makes the linked binaries compatible even if built on
|
|
# a newer version of the OS.
|
|
MACOSX_VERSION_MIN=10.7.0
|
|
|
|
|
|
# Setting --with-macosx-version-max=<version> makes it an error to build or
|
|
# link to macosx APIs that are newer than the given OS version. The expected
|
|
# format for <version> is either nn.n.n or nn.nn.nn. See /usr/include/AvailabilityMacros.h.
|
|
|
|
# Check whether --with-macosx-version-max was given.
|
|
if test "${with_macosx_version_max+set}" = set; then :
|
|
withval=$with_macosx_version_max;
|
|
if echo "$with_macosx_version_max" | $GREP -q "^[0-9][0-9]\.[0-9]\.[0-9]\$"; then
|
|
MACOSX_VERSION_MAX=$with_macosx_version_max
|
|
elif echo "$with_macosx_version_max" | $GREP -q "^[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9]\$"; then
|
|
MACOSX_VERSION_MAX=$with_macosx_version_max
|
|
elif test "x$with_macosx_version_max" = "xno"; then
|
|
# Use build system default
|
|
MACOSX_VERSION_MAX=
|
|
else
|
|
as_fn_error $? "osx version format must be nn.n.n or nn.nn.nn" "$LINENO" 5
|
|
fi
|
|
|
|
else
|
|
MACOSX_VERSION_MAX=
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Let the flags variables get resolved in make for easier override on make
|
|
# command line. AvailabilityMacros.h versions have no dots, ex: 1070.
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
|
|
-DMAC_OS_X_VERSION_MIN_REQUIRED=\$(subst .,,\$(MACOSX_VERSION_MIN)) \
|
|
-mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
|
|
LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
|
|
JVM_CFLAGS="$JVM_CFLAGS \
|
|
-DMAC_OS_X_VERSION_MIN_REQUIRED=\$(subst .,,\$(MACOSX_VERSION_MIN)) \
|
|
-mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
|
|
|
|
if test -n "$MACOSX_VERSION_MAX"; then
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
|
|
-DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MAX))"
|
|
JVM_CFLAGS="$JVM_CFLAGS \
|
|
-DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MAX))"
|
|
fi
|
|
fi
|
|
|
|
# Setup some hard coded includes
|
|
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
|
|
-I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base \
|
|
-I${JDK_TOPDIR}/src/java.base/share/native/include \
|
|
-I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS/native/include \
|
|
-I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/include \
|
|
-I${JDK_TOPDIR}/src/java.base/share/native/libjava \
|
|
-I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/libjava"
|
|
|
|
# The shared libraries are compiled using the picflag.
|
|
CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK \
|
|
$CFLAGS_JDK $EXTRA_CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
|
|
CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK \
|
|
$CXXFLAGS_JDK $EXTRA_CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA"
|
|
|
|
# Executable flags
|
|
CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $EXTRA_CFLAGS_JDK"
|
|
CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $EXTRA_CXXFLAGS_JDK"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Setup LDFLAGS et al.
|
|
#
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
LDFLAGS_MICROSOFT="-nologo -opt:ref"
|
|
LDFLAGS_JDK="$LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
|
|
LDFLAGS_SAFESH="-safeseh"
|
|
LDFLAGS_JDK="$LDFLAGS_JDK $LDFLAGS_SAFESH"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_SAFESH"
|
|
# NOTE: Old build added -machine. Probably not needed.
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -machine:I386"
|
|
else
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -machine:AMD64"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# If this is a --hash-style=gnu system, use --hash-style=both, why?
|
|
# We have previously set HAS_GNU_HASH if this is the case
|
|
if test -n "$HAS_GNU_HASH"; then
|
|
LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_HASH_STYLE"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_HASH_STYLE"
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
# And since we now know that the linker is gnu, then add -z defs, to forbid
|
|
# undefined symbols in object files.
|
|
LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_NO_UNDEF_SYM"
|
|
LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -march=i586"
|
|
fi
|
|
case $DEBUG_LEVEL in
|
|
release )
|
|
# tell linker to optimize libraries.
|
|
# Should this be supplied to the OSS linker as well?
|
|
LDFLAGS_DEBUGLEVEL_release="-Wl,-O1"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_DEBUGLEVEL_release"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_DEBUGLEVEL_release"
|
|
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_RELRO_FLAG"
|
|
fi
|
|
;;
|
|
slowdebug )
|
|
# Hotspot always let the linker optimize
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-O1"
|
|
if test "x$HAS_LINKER_NOW" = "xtrue"; then
|
|
# do relocations at load
|
|
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG"
|
|
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_NOW_FLAG"
|
|
fi
|
|
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
|
|
# mark relocations read only
|
|
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
|
|
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_RELRO_FLAG"
|
|
fi
|
|
;;
|
|
fastdebug )
|
|
# Hotspot always let the linker optimize
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -Wl,-O1"
|
|
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
|
|
# mark relocations read only
|
|
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
|
|
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LINKER_RELRO_FLAG"
|
|
fi
|
|
;;
|
|
* )
|
|
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
|
|
;;
|
|
esac
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
|
|
LDFLAGS_JDK="$LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
|
|
LDFLAGS_CXX_SOLSTUDIO="-norunpath"
|
|
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
|
|
if test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -xarch=sparc"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok"
|
|
LDFLAGS_JDK="${LDFLAGS_JDK} $LDFLAGS_XLC"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $LDFLAGS_XLC"
|
|
# We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
|
|
# Hotspot now overflows its 64K TOC (currently only for slowdebug),
|
|
# so for slowdebug we build with '-qpic=large -bbigtoc'.
|
|
if test "x$DEBUG_LEVEL" = xslowdebug; then
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -bbigtoc"
|
|
fi
|
|
fi
|
|
|
|
# Customize LDFLAGS for executables
|
|
|
|
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
|
|
LDFLAGS_STACK_SIZE=1048576
|
|
else
|
|
LDFLAGS_STACK_SIZE=327680
|
|
fi
|
|
LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
|
|
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
|
|
fi
|
|
|
|
LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} ${EXTRA_LDFLAGS_JDK}"
|
|
|
|
# Customize LDFLAGS for libs
|
|
LDFLAGS_JDKLIB="${LDFLAGS_JDK}"
|
|
|
|
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS}"
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
|
|
-libpath:${OUTPUT_ROOT}/support/modules_libs/java.base"
|
|
JDKLIB_LIBS=""
|
|
else
|
|
JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base"
|
|
|
|
if test "xTARGET" = "xTARGET"; then
|
|
# On some platforms (mac) the linker warns about non existing -L dirs.
|
|
# For any of the variants server, client or minimal, the dir matches the
|
|
# variant name. The "main" variant should be used for linking. For the
|
|
# rest, the dir is just server.
|
|
if [[ " $JVM_VARIANTS " =~ " server " ]] || [[ " $JVM_VARIANTS " =~ " client " ]] \
|
|
|| [[ " $JVM_VARIANTS " =~ " minimal " ]] ; then
|
|
JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/$JVM_VARIANT_MAIN"
|
|
else
|
|
JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/server"
|
|
fi
|
|
elif test "xTARGET" = "xBUILD"; then
|
|
# When building a buildjdk, it's always only the server variant
|
|
JAVA_BASE_LDFLAGS="${JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/server"
|
|
fi
|
|
|
|
JDKLIB_LIBS="-ljava -ljvm"
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
JDKLIB_LIBS="$JDKLIB_LIBS -lc"
|
|
fi
|
|
|
|
fi
|
|
|
|
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${JAVA_BASE_LDFLAGS}"
|
|
|
|
# Set JVM_LIBS (per os)
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
JVM_LIBS="$JVM_LIBS -lm -ldl -lpthread"
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
# FIXME: This hard-coded path is not really proper.
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
|
|
SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
|
|
fi
|
|
JVM_LIBS="$JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
|
|
-lthread -ldoor -lc -ldemangle -lnsl -lrt"
|
|
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
JVM_LIBS="$JVM_LIBS -lm"
|
|
elif test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
JVM_LIBS="$JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
|
|
elif test "x$OPENJDK_TARGET_OS" = xbsd; then
|
|
JVM_LIBS="$JVM_LIBS -lm"
|
|
elif test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
JVM_LIBS="$JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
|
|
comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
|
|
wsock32.lib winmm.lib version.lib psapi.lib"
|
|
fi
|
|
|
|
# Set JVM_ASFLAGS
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
|
JVM_ASFLAGS="$JVM_ASFLAGS -march=i586"
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
JVM_ASFLAGS="$JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
|
|
fi
|
|
|
|
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${EXTRA_LDFLAGS_JDK}"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Special extras...
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
if test "x$OPENJDK_BUILD_CPU_ARCH" = "xsparc"; then
|
|
OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
|
|
OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
|
|
fi
|
|
OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
|
|
OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA="${OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt"
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
OPENJDK_BUILD_CXXSTD_CXXFLAG="-std=gnu++98"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$OPENJDK_BUILD_CXXSTD_CXXFLAG -Werror\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"$OPENJDK_BUILD_CXXSTD_CXXFLAG -Werror\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG $OPENJDK_BUILD_CXXSTD_CXXFLAG -Werror"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
|
|
else
|
|
:
|
|
OPENJDK_BUILD_CXXSTD_CXXFLAG=""
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} ${OPENJDK_BUILD_CXXSTD_CXXFLAG}"
|
|
OPENJDK_BUILD_JVM_CFLAGS="${OPENJDK_BUILD_JVM_CFLAGS} ${OPENJDK_BUILD_CXXSTD_CXXFLAG}"
|
|
|
|
fi
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -D__solaris__"
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} -D__solaris__"
|
|
fi
|
|
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} ${OPENJDK_BUILD_EXTRA_CFLAGS}"
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="${OPENJDK_BUILD_CXXFLAGS_JDK} ${OPENJDK_BUILD_EXTRA_CXXFLAGS}"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} ${OPENJDK_BUILD_EXTRA_LDFLAGS}"
|
|
|
|
###############################################################################
|
|
#
|
|
# Now setup the CFLAGS and LDFLAGS for the JDK build.
|
|
# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
|
|
#
|
|
|
|
# Setup compiler/platform specific flags into
|
|
# OPENJDK_BUILD_CFLAGS_JDK - C Compiler flags
|
|
# OPENJDK_BUILD_CXXFLAGS_JDK - C++ Compiler flags
|
|
# OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK - common to C and C++
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_GNU_SOURCE"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_REENTRANT"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -fcheck-new"
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
# Force compatibility with i586 on 32 bit intel platforms.
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS="${OPENJDK_BUILD_COMMON_CCXXFLAGS} -march=i586"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -march=i586"
|
|
fi
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
|
|
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
|
|
case $OPENJDK_BUILD_CPU_ARCH in
|
|
arm )
|
|
# on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="${OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK} -fsigned-char"
|
|
;;
|
|
ppc )
|
|
# on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
s390 )
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer -mbackchain -march=z10"
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
* )
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
esac
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
# Need to assign to a variable since m4 is blocked from modifying parts in [].
|
|
REFERENCE_VERSION=6
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ (.*\.){4} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 6, only four parts (W.X.Y.Z) is supported" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 6, only parts < 99999 is supported" "$LINENO" 5
|
|
fi
|
|
|
|
# Version comparison method inspired by http://stackoverflow.com/a/24067243
|
|
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$REFERENCE_VERSION"`
|
|
|
|
if test $OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
|
|
:
|
|
|
|
# These flags are required for GCC 6 builds as undefined behaviour in OpenJDK code
|
|
# runs afoul of the more aggressive versions of these optimisations.
|
|
# Notably, value range propagation now assumes that the this pointer of C++
|
|
# member functions is non-null.
|
|
NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
|
|
NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&5
|
|
$as_echo "$as_me: GCC >= 6 detected; adding ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} and ${NO_LIFETIME_DSE_CFLAG}" >&6;}
|
|
OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS ${NO_DELETE_NULL_POINTER_CHECKS_CFLAG} ${NO_LIFETIME_DSE_CFLAG}"
|
|
|
|
else
|
|
:
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_GNU_SOURCE"
|
|
|
|
# Restrict the debug information created by Clang to avoid
|
|
# too big object files and speed the build up a little bit
|
|
# (see http://llvm.org/bugs/show_bug.cgi?id=7554)
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -flimit-debug-info"
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
# Force compatibility with i586 on 32 bit intel platforms.
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS="${OPENJDK_BUILD_COMMON_CCXXFLAGS} -march=i586"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -march=i586"
|
|
fi
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-sometimes-uninitialized"
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
|
|
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
|
|
case $OPENJDK_BUILD_CPU_ARCH in
|
|
ppc )
|
|
# on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
* )
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
|
|
OPENJDK_BUILD_CFLAGS_JDK="${OPENJDK_BUILD_CFLAGS_JDK} -fno-strict-aliasing"
|
|
;;
|
|
esac
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DSPARC_WORKS"
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
|
|
if test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_BUILD_CPU_LEGACY_LIB"
|
|
fi
|
|
|
|
OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="$OPENJDK_BUILD_CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_REENTRANT"
|
|
OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="$OPENJDK_BUILD_CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
|
|
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS $OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
-MD -Zc:wchar_t- -W3 -wd4800 \
|
|
-DWIN32_LEAN_AND_MEAN \
|
|
-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
|
|
-D_WINSOCK_DEPRECATED_NO_WARNINGS \
|
|
-DWIN32 -DIAL"
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
|
|
else
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
|
|
fi
|
|
# If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
|
|
# avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual
|
|
# studio.
|
|
if test "x$TOOLCHAIN_VERSION" = "x2010"; then
|
|
STATIC_CPPLIB_FLAGS="-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB"
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK $STATIC_CPPLIB_FLAGS"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS $STATIC_CPPLIB_FLAGS"
|
|
fi
|
|
fi
|
|
|
|
###############################################################################
|
|
|
|
# Adjust flags according to debug level.
|
|
case $DEBUG_LEVEL in
|
|
fastdebug | slowdebug )
|
|
OPENJDK_BUILD_CFLAGS_JDK="$OPENJDK_BUILD_CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
|
|
OPENJDK_BUILD_CXXFLAGS_JDK="$OPENJDK_BUILD_CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
|
|
;;
|
|
release )
|
|
;;
|
|
* )
|
|
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
|
|
;;
|
|
esac
|
|
|
|
# Set some common defines. These works for all compilers, but assume
|
|
# -D is universally accepted.
|
|
|
|
# Setup endianness
|
|
if test "x$OPENJDK_BUILD_CPU_ENDIAN" = xlittle; then
|
|
# The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
|
|
# Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
|
|
# (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
|
|
# Note: -Dmacro is the same as #define macro 1
|
|
# -Dmacro= is the same as #define macro
|
|
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
|
|
else
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
|
|
fi
|
|
else
|
|
# Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
|
|
# are defined in the system?
|
|
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
|
|
else
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
|
|
fi
|
|
fi
|
|
|
|
# Always enable optional macros for VM.
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D__STDC_FORMAT_MACROS"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D__STDC_LIMIT_MACROS"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D__STDC_CONSTANT_MACROS"
|
|
|
|
# Setup target OS define. Use OS target name but in upper case.
|
|
OPENJDK_BUILD_OS_UPPERCASE=`$ECHO $OPENJDK_BUILD_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D$OPENJDK_BUILD_OS_UPPERCASE"
|
|
|
|
# Setup target CPU
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
$OPENJDK_BUILD_ADD_LP64 \
|
|
-DARCH='\"$OPENJDK_BUILD_CPU_LEGACY\"' -D$OPENJDK_BUILD_CPU_LEGACY"
|
|
|
|
# Setup debug/release defines
|
|
if test "x$DEBUG_LEVEL" = xrelease; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DNDEBUG"
|
|
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DTRIMMED"
|
|
fi
|
|
else
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -DDEBUG"
|
|
fi
|
|
|
|
# Optional POSIX functionality needed by the VM
|
|
|
|
if test "x$HAS_CLOCK_GETTIME" = "xtrue"; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DSUPPORTS_CLOCK_MONOTONIC"
|
|
if test "x$CLOCK_GETTIME_IN_LIBRT" = "xtrue"; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DNEEDS_LIBRT"
|
|
fi
|
|
fi
|
|
|
|
|
|
# Set some additional per-OS defines.
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DLINUX"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -pipe $PICFLAG -fno-rtti -fno-exceptions \
|
|
-fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
|
|
elif test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DSOLARIS"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -template=no%extdef -features=no%split_init \
|
|
-D_Crun_inline_placement -library=stlport4 $PICFLAG -mt -features=no%except"
|
|
elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_ALLBSD_SOURCE"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
|
|
-mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
|
|
-fno-omit-frame-pointer"
|
|
elif test "x$OPENJDK_BUILD_OS" = xaix; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DAIX"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -qtune=balanced \
|
|
-qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
|
|
-qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
|
|
# We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
|
|
# Hotspot now overflows its 64K TOC (currently only for slowdebug),
|
|
# so for slowdebug we build with '-qpic=large -bbigtoc'.
|
|
if test "x$DEBUG_LEVEL" = xslowdebug; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -qpic=large"
|
|
fi
|
|
elif test "x$OPENJDK_BUILD_OS" = xbsd; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
|
|
elif test "x$OPENJDK_BUILD_OS" = xwindows; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -nologo -W3 -MD -MP"
|
|
fi
|
|
|
|
# Set some additional per-CPU defines.
|
|
if test "x$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" = xwindows-x86; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -arch:IA32"
|
|
elif test "x$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" = xsolaris-sparcv9; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -xarch=sparc"
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc64; then
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
|
|
# fixes `relocation truncated to fit' error for gcc 4.1.
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mminimal-toc"
|
|
# Use ppc64 instructions, but schedule for power5
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
|
|
elif test "x$OPENJDK_BUILD_OS" = xaix; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -qarch=ppc64"
|
|
fi
|
|
elif test "x$OPENJDK_BUILD_CPU" = xppc64le; then
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
|
|
# Little endian machine uses ELFv2 ABI.
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DABI_ELFv2"
|
|
# Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mcpu=power8 -mtune=power8"
|
|
fi
|
|
elif test "x$OPENJDK_BUILD_CPU" = xs390x; then
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -mbackchain -march=z10"
|
|
fi
|
|
fi
|
|
|
|
if test "x$OPENJDK_BUILD_CPU_ENDIAN" = xlittle; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -DVM_LITTLE_ENDIAN"
|
|
fi
|
|
|
|
if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
|
|
if test "x$OPENJDK_BUILD_OS" != xsolaris && test "x$OPENJDK_BUILD_OS" != xaix; then
|
|
# Solaris does not have _LP64=1 in the old build.
|
|
# xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_LP64=1"
|
|
fi
|
|
fi
|
|
|
|
# Set OPENJDK_BUILD_JVM_CFLAGS warning handling
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
|
|
-Wunused-value -Woverloaded-virtual"
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
# Need to assign to a variable since m4 is blocked from modifying parts in [].
|
|
REFERENCE_VERSION=4.8
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ (.*\.){4} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 4.8, only four parts (W.X.Y.Z) is supported" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ "$REFERENCE_VERSION" =~ [0-9]{6} ]] ; then
|
|
as_fn_error $? "Internal error: Cannot compare to 4.8, only parts < 99999 is supported" "$LINENO" 5
|
|
fi
|
|
|
|
# Version comparison method inspired by http://stackoverflow.com/a/24067243
|
|
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d%05d\n", $1, $2, $3, $4) }' <<< "$REFERENCE_VERSION"`
|
|
|
|
if test $OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
|
|
:
|
|
|
|
# These flags either do not work or give spurious warnings prior to gcc 4.8.
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-format-zero-length -Wtype-limits -Wuninitialized"
|
|
|
|
|
|
else
|
|
:
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fi
|
|
if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
# Non-zero builds have stricter warnings
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wreturn-type -Wundef -Wformat=2"
|
|
else
|
|
if test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
# Some versions of llvm do not like -Wundef
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-undef"
|
|
fi
|
|
fi
|
|
elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
|
|
-Wsign-compare -Wundef -Wunused-function -Wformat=2"
|
|
fi
|
|
|
|
# Additional macosx handling
|
|
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
# MACOSX_VERSION_MIN is the c++ and ld is -mmacosx-version-min argument. The expected
|
|
# format is X.Y.Z. It's hard-coded to the minimum OSX version on which the
|
|
# JDK can be built and makes the linked binaries compatible even if built on
|
|
# a newer version of the OS.
|
|
MACOSX_VERSION_MIN=10.7.0
|
|
|
|
|
|
# Setting --with-macosx-version-max=<version> makes it an error to build or
|
|
# link to macosx APIs that are newer than the given OS version. The expected
|
|
# format for <version> is either nn.n.n or nn.nn.nn. See /usr/include/AvailabilityMacros.h.
|
|
|
|
# Check whether --with-macosx-version-max was given.
|
|
if test "${with_macosx_version_max+set}" = set; then :
|
|
withval=$with_macosx_version_max;
|
|
if echo "$with_macosx_version_max" | $GREP -q "^[0-9][0-9]\.[0-9]\.[0-9]\$"; then
|
|
MACOSX_VERSION_MAX=$with_macosx_version_max
|
|
elif echo "$with_macosx_version_max" | $GREP -q "^[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9]\$"; then
|
|
MACOSX_VERSION_MAX=$with_macosx_version_max
|
|
elif test "x$with_macosx_version_max" = "xno"; then
|
|
# Use build system default
|
|
MACOSX_VERSION_MAX=
|
|
else
|
|
as_fn_error $? "osx version format must be nn.n.n or nn.nn.nn" "$LINENO" 5
|
|
fi
|
|
|
|
else
|
|
MACOSX_VERSION_MAX=
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Let the flags variables get resolved in make for easier override on make
|
|
# command line. AvailabilityMacros.h versions have no dots, ex: 1070.
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
-DMAC_OS_X_VERSION_MIN_REQUIRED=\$(subst .,,\$(MACOSX_VERSION_MIN)) \
|
|
-mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS \
|
|
-DMAC_OS_X_VERSION_MIN_REQUIRED=\$(subst .,,\$(MACOSX_VERSION_MIN)) \
|
|
-mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
|
|
|
|
if test -n "$MACOSX_VERSION_MAX"; then
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
-DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MAX))"
|
|
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS \
|
|
-DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MAX))"
|
|
fi
|
|
fi
|
|
|
|
# Setup some hard coded includes
|
|
OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
-I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base \
|
|
-I${JDK_TOPDIR}/src/java.base/share/native/include \
|
|
-I${JDK_TOPDIR}/src/java.base/$OPENJDK_BUILD_OS/native/include \
|
|
-I${JDK_TOPDIR}/src/java.base/$OPENJDK_BUILD_OS_TYPE/native/include \
|
|
-I${JDK_TOPDIR}/src/java.base/share/native/libjava \
|
|
-I${JDK_TOPDIR}/src/java.base/$OPENJDK_BUILD_OS_TYPE/native/libjava"
|
|
|
|
# The shared libraries are compiled using the picflag.
|
|
OPENJDK_BUILD_CFLAGS_JDKLIB="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
$OPENJDK_BUILD_CFLAGS_JDK $OPENJDK_BUILD_EXTRA_CFLAGS_JDK $PICFLAG $OPENJDK_BUILD_CFLAGS_JDKLIB_EXTRA"
|
|
OPENJDK_BUILD_CXXFLAGS_JDKLIB="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK \
|
|
$OPENJDK_BUILD_CXXFLAGS_JDK $OPENJDK_BUILD_EXTRA_CXXFLAGS_JDK $PICFLAG $OPENJDK_BUILD_CXXFLAGS_JDKLIB_EXTRA"
|
|
|
|
# Executable flags
|
|
OPENJDK_BUILD_CFLAGS_JDKEXE="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK $OPENJDK_BUILD_CFLAGS_JDK $OPENJDK_BUILD_EXTRA_CFLAGS_JDK"
|
|
OPENJDK_BUILD_CXXFLAGS_JDKEXE="$OPENJDK_BUILD_COMMON_CCXXFLAGS_JDK $OPENJDK_BUILD_CXXFLAGS_JDK $OPENJDK_BUILD_EXTRA_CXXFLAGS_JDK"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Setup LDFLAGS et al.
|
|
#
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
LDFLAGS_MICROSOFT="-nologo -opt:ref"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
|
|
if test "x$OPENJDK_BUILD_CPU_BITS" = "x32"; then
|
|
LDFLAGS_SAFESH="-safeseh"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LDFLAGS_SAFESH"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_SAFESH"
|
|
# NOTE: Old build added -machine. Probably not needed.
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -machine:I386"
|
|
else
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -machine:AMD64"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xclang; then
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
|
|
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
# FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
# If this is a --hash-style=gnu system, use --hash-style=both, why?
|
|
# We have previously set HAS_GNU_HASH if this is the case
|
|
if test -n "$HAS_GNU_HASH"; then
|
|
OPENJDK_BUILD_LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $OPENJDK_BUILD_LDFLAGS_HASH_STYLE"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $OPENJDK_BUILD_LDFLAGS_HASH_STYLE"
|
|
fi
|
|
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
|
|
fi
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
# And since we now know that the linker is gnu, then add -z defs, to forbid
|
|
# undefined symbols in object files.
|
|
LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_NO_UNDEF_SYM"
|
|
LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -march=i586"
|
|
fi
|
|
case $DEBUG_LEVEL in
|
|
release )
|
|
# tell linker to optimize libraries.
|
|
# Should this be supplied to the OSS linker as well?
|
|
LDFLAGS_DEBUGLEVEL_release="-Wl,-O1"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $LDFLAGS_DEBUGLEVEL_release"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_DEBUGLEVEL_release"
|
|
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_RELRO_FLAG"
|
|
fi
|
|
;;
|
|
slowdebug )
|
|
# Hotspot always let the linker optimize
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-O1"
|
|
if test "x$HAS_LINKER_NOW" = "xtrue"; then
|
|
# do relocations at load
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LINKER_NOW_FLAG"
|
|
OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_NOW_FLAG"
|
|
fi
|
|
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
|
|
# mark relocations read only
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LINKER_RELRO_FLAG"
|
|
OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_RELRO_FLAG"
|
|
fi
|
|
;;
|
|
fastdebug )
|
|
# Hotspot always let the linker optimize
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -Wl,-O1"
|
|
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
|
|
# mark relocations read only
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LINKER_RELRO_FLAG"
|
|
OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LINKER_RELRO_FLAG"
|
|
fi
|
|
;;
|
|
* )
|
|
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
|
|
;;
|
|
esac
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="$OPENJDK_BUILD_LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
|
|
LDFLAGS_CXX_SOLSTUDIO="-norunpath"
|
|
OPENJDK_BUILD_LDFLAGS_CXX_JDK="$OPENJDK_BUILD_LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
|
|
if test "x$OPENJDK_BUILD_CPU_ARCH" = "xsparc"; then
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -xarch=sparc"
|
|
fi
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok"
|
|
OPENJDK_BUILD_LDFLAGS_JDK="${OPENJDK_BUILD_LDFLAGS_JDK} $LDFLAGS_XLC"
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $LDFLAGS_XLC"
|
|
# We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
|
|
# Hotspot now overflows its 64K TOC (currently only for slowdebug),
|
|
# so for slowdebug we build with '-qpic=large -bbigtoc'.
|
|
if test "x$DEBUG_LEVEL" = xslowdebug; then
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -bbigtoc"
|
|
fi
|
|
fi
|
|
|
|
# Customize LDFLAGS for executables
|
|
|
|
OPENJDK_BUILD_LDFLAGS_JDKEXE="${OPENJDK_BUILD_LDFLAGS_JDK}"
|
|
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
if test "x$OPENJDK_BUILD_CPU_BITS" = "x64"; then
|
|
LDFLAGS_STACK_SIZE=1048576
|
|
else
|
|
LDFLAGS_STACK_SIZE=327680
|
|
fi
|
|
OPENJDK_BUILD_LDFLAGS_JDKEXE="${OPENJDK_BUILD_LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
|
|
elif test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_LDFLAGS_JDKEXE="$OPENJDK_BUILD_LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
|
|
fi
|
|
|
|
OPENJDK_BUILD_LDFLAGS_JDKEXE="${OPENJDK_BUILD_LDFLAGS_JDKEXE} ${OPENJDK_BUILD_EXTRA_LDFLAGS_JDK}"
|
|
|
|
# Customize LDFLAGS for libs
|
|
OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDK}"
|
|
|
|
OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS}"
|
|
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
|
OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
|
|
-libpath:${OUTPUT_ROOT}/support/modules_libs/java.base"
|
|
OPENJDK_BUILD_JDKLIB_LIBS=""
|
|
else
|
|
OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base"
|
|
|
|
if test "xBUILD" = "xTARGET"; then
|
|
# On some platforms (mac) the linker warns about non existing -L dirs.
|
|
# For any of the variants server, client or minimal, the dir matches the
|
|
# variant name. The "main" variant should be used for linking. For the
|
|
# rest, the dir is just server.
|
|
if [[ " $JVM_VARIANTS " =~ " server " ]] || [[ " $JVM_VARIANTS " =~ " client " ]] \
|
|
|| [[ " $JVM_VARIANTS " =~ " minimal " ]] ; then
|
|
OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/$JVM_VARIANT_MAIN"
|
|
else
|
|
OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/server"
|
|
fi
|
|
elif test "xBUILD" = "xBUILD"; then
|
|
# When building a buildjdk, it's always only the server variant
|
|
OPENJDK_BUILD_JAVA_BASE_LDFLAGS="${OPENJDK_BUILD_JAVA_BASE_LDFLAGS} \
|
|
-L\$(SUPPORT_OUTPUTDIR)/modules_libs/java.base/server"
|
|
fi
|
|
|
|
OPENJDK_BUILD_JDKLIB_LIBS="-ljava -ljvm"
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
OPENJDK_BUILD_JDKLIB_LIBS="$OPENJDK_BUILD_JDKLIB_LIBS -lc"
|
|
fi
|
|
|
|
fi
|
|
|
|
OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDKLIB} ${OPENJDK_BUILD_JAVA_BASE_LDFLAGS}"
|
|
|
|
# Set OPENJDK_BUILD_JVM_LIBS (per os)
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lm -ldl -lpthread"
|
|
elif test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
|
# FIXME: This hard-coded path is not really proper.
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
|
OPENJDK_BUILD_SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
|
|
elif test "x$OPENJDK_BUILD_CPU" = xsparcv9; then
|
|
OPENJDK_BUILD_SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
|
|
fi
|
|
OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
|
|
-lthread -ldoor -lc -ldemangle -lnsl -lrt"
|
|
elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lm"
|
|
elif test "x$OPENJDK_BUILD_OS" = xaix; then
|
|
OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
|
|
elif test "x$OPENJDK_BUILD_OS" = xbsd; then
|
|
OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS -lm"
|
|
elif test "x$OPENJDK_BUILD_OS" = xwindows; then
|
|
OPENJDK_BUILD_JVM_LIBS="$OPENJDK_BUILD_JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
|
|
comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
|
|
wsock32.lib winmm.lib version.lib psapi.lib"
|
|
fi
|
|
|
|
# Set OPENJDK_BUILD_JVM_ASFLAGS
|
|
if test "x$OPENJDK_BUILD_OS" = xlinux; then
|
|
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
|
OPENJDK_BUILD_JVM_ASFLAGS="$OPENJDK_BUILD_JVM_ASFLAGS -march=i586"
|
|
fi
|
|
elif test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
|
OPENJDK_BUILD_JVM_ASFLAGS="$OPENJDK_BUILD_JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
|
|
fi
|
|
|
|
OPENJDK_BUILD_LDFLAGS_JDKLIB="${OPENJDK_BUILD_LDFLAGS_JDKLIB} ${OPENJDK_BUILD_EXTRA_LDFLAGS_JDK}"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Tests are only ever compiled for TARGET
|
|
# Flags for compiling test libraries
|
|
CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
|
|
CXXFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA"
|
|
|
|
# Flags for compiling test executables
|
|
CFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
|
|
CXXFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LDFLAGS_TESTLIB="$LDFLAGS_JDKLIB"
|
|
LDFLAGS_TESTEXE="$LDFLAGS_JDKEXE $JAVA_BASE_LDFLAGS"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check that the compiler supports -mX (or -qX on AIX) flags
|
|
# Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
|
|
$as_echo_n "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cflags="$CFLAGS"
|
|
CFLAGS="$CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CFLAGS="$saved_cflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
C_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
C_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
CXX_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
CXX_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
|
|
$as_echo_n "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
|
|
supports=no
|
|
if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
|
|
else
|
|
:
|
|
COMPILER_SUPPORTS_TARGET_BITS_FLAG=false
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --enable-warnings-as-errors was given.
|
|
if test "${enable_warnings_as_errors+set}" = set; then :
|
|
enableval=$enable_warnings_as_errors;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if native warnings are errors" >&5
|
|
$as_echo_n "checking if native warnings are errors... " >&6; }
|
|
if test "x$enable_warnings_as_errors" = "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (explicitly set)" >&5
|
|
$as_echo "yes (explicitly set)" >&6; }
|
|
WARNINGS_AS_ERRORS=true
|
|
elif test "x$enable_warnings_as_errors" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
WARNINGS_AS_ERRORS=false
|
|
elif test "x$enable_warnings_as_errors" = "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (default)" >&5
|
|
$as_echo "yes (default)" >&6; }
|
|
WARNINGS_AS_ERRORS=true
|
|
else
|
|
as_fn_error $? "--enable-warnings-as-errors accepts no argument" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
case "${TOOLCHAIN_TYPE}" in
|
|
microsoft)
|
|
DISABLE_WARNING_PREFIX="-wd"
|
|
CFLAGS_WARNINGS_ARE_ERRORS="-WX"
|
|
;;
|
|
solstudio)
|
|
DISABLE_WARNING_PREFIX="-erroff="
|
|
CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all"
|
|
;;
|
|
gcc)
|
|
# Prior to gcc 4.4, a -Wno-X where X is unknown for that version of gcc will cause an error
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
|
|
$as_echo_n "checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cflags="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Wno-this-is-a-warning-that-do-not-exist"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CFLAGS="$saved_cflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
C_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
C_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG -Wno-this-is-a-warning-that-do-not-exist"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
CXX_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
CXX_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
|
|
$as_echo_n "checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
|
|
supports=no
|
|
if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
GCC_CAN_DISABLE_WARNINGS=true
|
|
else
|
|
:
|
|
GCC_CAN_DISABLE_WARNINGS=false
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if test "x$GCC_CAN_DISABLE_WARNINGS" = "xtrue"; then
|
|
DISABLE_WARNING_PREFIX="-Wno-"
|
|
else
|
|
DISABLE_WARNING_PREFIX=
|
|
fi
|
|
CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
|
|
# Repeate the check for the BUILD_CC and BUILD_CXX. Need to also reset
|
|
# CFLAGS since any target specific flags will likely not work with the
|
|
# build compiler
|
|
CC_OLD="$CC"
|
|
CXX_OLD="$CXX"
|
|
CC="$BUILD_CC"
|
|
CXX="$BUILD_CXX"
|
|
CFLAGS_OLD="$CFLAGS"
|
|
CFLAGS=""
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
|
|
$as_echo_n "checking if the C compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cflags="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Wno-this-is-a-warning-that-do-not-exist"
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CFLAGS="$saved_cflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
C_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
C_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Execute function body
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
|
|
$as_echo_n "checking if the C++ compiler supports \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
|
|
supports=yes
|
|
|
|
saved_cxxflags="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAG -Wno-this-is-a-warning-that-do-not-exist"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
int i;
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
|
|
else
|
|
supports=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
CXXFLAGS="$saved_cxxflags"
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
CXX_COMP_SUPPORTS="yes"
|
|
else
|
|
:
|
|
CXX_COMP_SUPPORTS="no"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"" >&5
|
|
$as_echo_n "checking if both compilers support \"-Wno-this-is-a-warning-that-do-not-exist\"... " >&6; }
|
|
supports=no
|
|
if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
|
|
$as_echo "$supports" >&6; }
|
|
if test "x$supports" = "xyes" ; then
|
|
:
|
|
BUILD_CC_CAN_DISABLE_WARNINGS=true
|
|
else
|
|
:
|
|
BUILD_CC_CAN_DISABLE_WARNINGS=false
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if test "x$BUILD_CC_CAN_DISABLE_WARNINGS" = "xtrue"; then
|
|
BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-"
|
|
else
|
|
BUILD_CC_DISABLE_WARNING_PREFIX=
|
|
fi
|
|
CC="$CC_OLD"
|
|
CXX="$CXX_OLD"
|
|
CFLAGS="$CFLAGS_OLD"
|
|
;;
|
|
clang)
|
|
DISABLE_WARNING_PREFIX="-Wno-"
|
|
CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
|
|
;;
|
|
xlc)
|
|
DISABLE_WARNING_PREFIX="-qsuppress="
|
|
CFLAGS_WARNINGS_ARE_ERRORS="-qhalt=w"
|
|
;;
|
|
esac
|
|
|
|
|
|
|
|
|
|
|
|
# Setup debug symbols (need objcopy from the toolchain for that)
|
|
|
|
#
|
|
# NATIVE_DEBUG_SYMBOLS
|
|
# This must be done after the toolchain is setup, since we're looking at objcopy.
|
|
#
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of native debug symbols to use" >&5
|
|
$as_echo_n "checking what type of native debug symbols to use... " >&6; }
|
|
|
|
# Check whether --with-native-debug-symbols was given.
|
|
if test "${with_native_debug_symbols+set}" = set; then :
|
|
withval=$with_native_debug_symbols;
|
|
if test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
if test "x$withval" = xexternal || test "x$withval" = xzipped; then
|
|
as_fn_error $? "AIX only supports the parameters 'none' and 'internal' for --with-native-debug-symbols" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
else
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xaix; then
|
|
# AIX doesn't support 'zipped' so use 'internal' as default
|
|
with_native_debug_symbols="internal"
|
|
else
|
|
if test "x$STATIC_BUILD" = xtrue; then
|
|
with_native_debug_symbols="none"
|
|
else
|
|
with_native_debug_symbols="zipped"
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
NATIVE_DEBUG_SYMBOLS=$with_native_debug_symbols
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NATIVE_DEBUG_SYMBOLS" >&5
|
|
$as_echo "$NATIVE_DEBUG_SYMBOLS" >&6; }
|
|
|
|
if test "x$NATIVE_DEBUG_SYMBOLS" = xzipped; then
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
if test "x$OBJCOPY" = x; then
|
|
# enabling of enable-debug-symbols and can't find objcopy
|
|
# this is an error
|
|
as_fn_error $? "Unable to find objcopy, cannot enable native debug symbols" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
COMPILE_WITH_DEBUG_SYMBOLS=true
|
|
COPY_DEBUG_SYMBOLS=true
|
|
ZIP_EXTERNAL_DEBUG_SYMBOLS=true
|
|
elif test "x$NATIVE_DEBUG_SYMBOLS" = xnone; then
|
|
COMPILE_WITH_DEBUG_SYMBOLS=false
|
|
COPY_DEBUG_SYMBOLS=false
|
|
ZIP_EXTERNAL_DEBUG_SYMBOLS=false
|
|
elif test "x$NATIVE_DEBUG_SYMBOLS" = xinternal; then
|
|
COMPILE_WITH_DEBUG_SYMBOLS=true
|
|
COPY_DEBUG_SYMBOLS=false
|
|
ZIP_EXTERNAL_DEBUG_SYMBOLS=false
|
|
elif test "x$NATIVE_DEBUG_SYMBOLS" = xexternal; then
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
if test "x$OBJCOPY" = x; then
|
|
# enabling of enable-debug-symbols and can't find objcopy
|
|
# this is an error
|
|
as_fn_error $? "Unable to find objcopy, cannot enable native debug symbols" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
COMPILE_WITH_DEBUG_SYMBOLS=true
|
|
COPY_DEBUG_SYMBOLS=true
|
|
ZIP_EXTERNAL_DEBUG_SYMBOLS=false
|
|
else
|
|
as_fn_error $? "Allowed native debug symbols are: none, internal, external, zipped" "$LINENO" 5
|
|
fi
|
|
|
|
# --enable-debug-symbols is deprecated.
|
|
# Please use --with-native-debug-symbols=[internal,external,zipped] .
|
|
|
|
# Check whether --enable-debug-symbols was given.
|
|
if test "${enable_debug_symbols+set}" = set; then :
|
|
enableval=$enable_debug_symbols;
|
|
fi
|
|
|
|
if test "x$enable_debug_symbols" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-debug-symbols is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --enable-debug-symbols is deprecated and will be ignored." >&2;}
|
|
|
|
if test "xPlease use --with-native-debug-symbols=[internal,external,zipped] ." != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Please use --with-native-debug-symbols=[internal,external,zipped] ." >&5
|
|
$as_echo "$as_me: WARNING: Please use --with-native-debug-symbols=[internal,external,zipped] ." >&2;}
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
# --enable-zip-debug-info is deprecated.
|
|
# Please use --with-native-debug-symbols=zipped .
|
|
|
|
# Check whether --enable-zip-debug-info was given.
|
|
if test "${enable_zip_debug_info+set}" = set; then :
|
|
enableval=$enable_zip_debug_info;
|
|
fi
|
|
|
|
if test "x$enable_zip_debug_info" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-zip-debug-info is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --enable-zip-debug-info is deprecated and will be ignored." >&2;}
|
|
|
|
if test "xPlease use --with-native-debug-symbols=zipped ." != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Please use --with-native-debug-symbols=zipped ." >&5
|
|
$as_echo "$as_me: WARNING: Please use --with-native-debug-symbols=zipped ." >&2;}
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --enable-native-coverage was given.
|
|
if test "${enable_native_coverage+set}" = set; then :
|
|
enableval=$enable_native_coverage;
|
|
fi
|
|
|
|
GCOV_ENABLED="false"
|
|
if test "x$enable_native_coverage" = "xyes"; then
|
|
if test "x$TOOLCHAIN_TYPE" = "xgcc"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if native coverage is enabled" >&5
|
|
$as_echo_n "checking if native coverage is enabled... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
GCOV_CFLAGS="-fprofile-arcs -ftest-coverage -fno-inline"
|
|
GCOV_LDFLAGS="-fprofile-arcs"
|
|
JVM_CFLAGS="$JVM_CFLAGS $GCOV_CFLAGS"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $GCOV_LDFLAGS"
|
|
CFLAGS_JDKLIB="$CFLAGS_JDKLIB $GCOV_CFLAGS"
|
|
CFLAGS_JDKEXE="$CFLAGS_JDKEXE $GCOV_CFLAGS"
|
|
CXXFLAGS_JDKLIB="$CXXFLAGS_JDKLIB $GCOV_CFLAGS"
|
|
CXXFLAGS_JDKEXE="$CXXFLAGS_JDKEXE $GCOV_CFLAGS"
|
|
LDFLAGS_JDKLIB="$LDFLAGS_JDKLIB $GCOV_LDFLAGS"
|
|
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE $GCOV_LDFLAGS"
|
|
GCOV_ENABLED="true"
|
|
else
|
|
as_fn_error $? "--enable-native-coverage only works with toolchain type gcc" "$LINENO" 5
|
|
fi
|
|
elif test "x$enable_native_coverage" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if native coverage is enabled" >&5
|
|
$as_echo_n "checking if native coverage is enabled... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
elif test "x$enable_native_coverage" != "x"; then
|
|
as_fn_error $? "--enable-native-coverage can only be assigned \"yes\" or \"no\"" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Need toolchain to setup dtrace
|
|
|
|
# Test for dtrace dependencies
|
|
# Check whether --enable-dtrace was given.
|
|
if test "${enable_dtrace+set}" = set; then :
|
|
enableval=$enable_dtrace;
|
|
fi
|
|
|
|
|
|
DTRACE_DEP_MISSING=false
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dtrace tool" >&5
|
|
$as_echo_n "checking for dtrace tool... " >&6; }
|
|
if test "x$DTRACE" != "x" && test -x "$DTRACE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DTRACE" >&5
|
|
$as_echo "$DTRACE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found, cannot build dtrace" >&5
|
|
$as_echo "not found, cannot build dtrace" >&6; }
|
|
DTRACE_DEP_MISSING=true
|
|
fi
|
|
|
|
for ac_header in sys/sdt.h
|
|
do :
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "sys/sdt.h" "ac_cv_header_sys_sdt_h" "$ac_includes_default"
|
|
if test "x$ac_cv_header_sys_sdt_h" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_SYS_SDT_H 1
|
|
_ACEOF
|
|
DTRACE_HEADERS_OK=yes
|
|
else
|
|
DTRACE_HEADERS_OK=no
|
|
fi
|
|
|
|
done
|
|
|
|
if test "x$DTRACE_HEADERS_OK" != "xyes"; then
|
|
DTRACE_DEP_MISSING=true
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if dtrace should be built" >&5
|
|
$as_echo_n "checking if dtrace should be built... " >&6; }
|
|
if test "x$enable_dtrace" = "xyes"; then
|
|
if test "x$DTRACE_DEP_MISSING" = "xtrue"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing dependencies" >&5
|
|
$as_echo "no, missing dependencies" >&6; }
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# dtrace is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=dtrace
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Cannot enable dtrace with missing dependencies. See above. $HELP_MSG" "$LINENO" 5
|
|
else
|
|
INCLUDE_DTRACE=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
fi
|
|
elif test "x$enable_dtrace" = "xno"; then
|
|
INCLUDE_DTRACE=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
elif test "x$enable_dtrace" = "xauto" || test "x$enable_dtrace" = "x"; then
|
|
if test "x$DTRACE_DEP_MISSING" = "xtrue"; then
|
|
INCLUDE_DTRACE=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing dependencies" >&5
|
|
$as_echo "no, missing dependencies" >&6; }
|
|
else
|
|
INCLUDE_DTRACE=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, dependencies present" >&5
|
|
$as_echo "yes, dependencies present" >&6; }
|
|
fi
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-dtrace: $enable_dtrace" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
# Check whether --enable-aot was given.
|
|
if test "${enable_aot+set}" = set; then :
|
|
enableval=$enable_aot;
|
|
fi
|
|
|
|
|
|
if test "x$enable_aot" = "x" || test "x$enable_aot" = "xauto"; then
|
|
ENABLE_AOT="true"
|
|
elif test "x$enable_aot" = "xyes"; then
|
|
ENABLE_AOT="true"
|
|
elif test "x$enable_aot" = "xno"; then
|
|
ENABLE_AOT="false"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if aot should be enabled" >&5
|
|
$as_echo_n "checking if aot should be enabled... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-aot: $enable_aot" "$LINENO" 5
|
|
fi
|
|
|
|
if test "x$ENABLE_AOT" = "xtrue"; then
|
|
# Only enable AOT on X64 platforms.
|
|
if test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
|
|
if test -e "$HOTSPOT_TOPDIR/src/jdk.aot"; then
|
|
if test -e "$HOTSPOT_TOPDIR/src/jdk.internal.vm.compiler"; then
|
|
ENABLE_AOT="true"
|
|
else
|
|
ENABLE_AOT="false"
|
|
if test "x$enable_aot" = "xyes"; then
|
|
as_fn_error $? "Cannot build AOT without hotspot/src/jdk.internal.vm.compiler sources. Remove --enable-aot." "$LINENO" 5
|
|
fi
|
|
fi
|
|
else
|
|
ENABLE_AOT="false"
|
|
if test "x$enable_aot" = "xyes"; then
|
|
as_fn_error $? "Cannot build AOT without hotspot/src/jdk.aot sources. Remove --enable-aot." "$LINENO" 5
|
|
fi
|
|
fi
|
|
else
|
|
ENABLE_AOT="false"
|
|
if test "x$enable_aot" = "xyes"; then
|
|
as_fn_error $? "AOT is currently only supported on x86_64. Remove --enable-aot." "$LINENO" 5
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --enable-cds was given.
|
|
if test "${enable_cds+set}" = set; then :
|
|
enableval=$enable_cds;
|
|
fi
|
|
|
|
|
|
if test "x$enable_cds" = "x" || test "x$enable_cds" = "xyes"; then
|
|
ENABLE_CDS="true"
|
|
elif test "x$enable_cds" = "xno"; then
|
|
ENABLE_CDS="false"
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-cds: $enable_cds" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --enable-hotspot-gtest was given.
|
|
if test "${enable_hotspot_gtest+set}" = set; then :
|
|
enableval=$enable_hotspot_gtest;
|
|
fi
|
|
|
|
|
|
if test -e "$HOTSPOT_TOPDIR/test/native"; then
|
|
GTEST_DIR_EXISTS="true"
|
|
else
|
|
GTEST_DIR_EXISTS="false"
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if Hotspot gtest unit tests should be built" >&5
|
|
$as_echo_n "checking if Hotspot gtest unit tests should be built... " >&6; }
|
|
if test "x$enable_hotspot_gtest" = "xyes"; then
|
|
if test "x$GTEST_DIR_EXISTS" = "xtrue"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
BUILD_GTEST="true"
|
|
else
|
|
as_fn_error $? "Cannot build gtest without the test source" "$LINENO" 5
|
|
fi
|
|
elif test "x$enable_hotspot_gtest" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
BUILD_GTEST="false"
|
|
elif test "x$enable_hotspot_gtest" = "x"; then
|
|
if test "x$GTEST_DIR_EXISTS" = "xtrue"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
BUILD_GTEST="true"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
BUILD_GTEST="false"
|
|
fi
|
|
else
|
|
as_fn_error $? "--enable-gtest must be either yes or no" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Check dependencies for external and internal libraries.
|
|
#
|
|
###############################################################################
|
|
|
|
# After we have toolchain, we can compile fixpath. It's needed by the lib checks.
|
|
|
|
# When using cygwin or msys, we need a wrapper binary that renames
|
|
# /cygdrive/c/ arguments into c:/ arguments and peeks into
|
|
# @files and rewrites these too! This wrapper binary is
|
|
# called fixpath.
|
|
FIXPATH=
|
|
if test "x$OPENJDK_BUILD_OS" = xwindows; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath can be created" >&5
|
|
$as_echo_n "checking if fixpath can be created... " >&6; }
|
|
FIXPATH_SRC="$SRC_ROOT/common/src/fixpath.c"
|
|
FIXPATH_BIN="$CONFIGURESUPPORT_OUTPUTDIR/bin/fixpath.exe"
|
|
FIXPATH_DIR="$CONFIGURESUPPORT_OUTPUTDIR/fixpath"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = xwindows.cygwin; then
|
|
# Important to keep the .exe suffix on Cygwin for Hotspot makefiles
|
|
FIXPATH="$FIXPATH_BIN -c"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = xwindows.msys; then
|
|
# Take all collected prefixes and turn them into a -m/c/foo@/c/bar@... command line
|
|
# @ was chosen as separator to minimize risk of other tools messing around with it
|
|
all_unique_prefixes=`echo "${all_fixpath_prefixes[@]}" \
|
|
| tr ' ' '\n' | $GREP '^/./' | $SORT | $UNIQ`
|
|
fixpath_argument_list=`echo $all_unique_prefixes | tr ' ' '@'`
|
|
FIXPATH="$FIXPATH_BIN -m$fixpath_argument_list"
|
|
fi
|
|
FIXPATH_SRC_W="$FIXPATH_SRC"
|
|
FIXPATH_BIN_W="$FIXPATH_BIN"
|
|
|
|
unix_path="$FIXPATH_SRC_W"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
FIXPATH_SRC_W="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
FIXPATH_SRC_W="$windows_path"
|
|
fi
|
|
|
|
|
|
unix_path="$FIXPATH_BIN_W"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
FIXPATH_BIN_W="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
FIXPATH_BIN_W="$windows_path"
|
|
fi
|
|
|
|
$RM -rf $FIXPATH_BIN $FIXPATH_DIR
|
|
$MKDIR -p $FIXPATH_DIR $CONFIGURESUPPORT_OUTPUTDIR/bin
|
|
cd $FIXPATH_DIR
|
|
$CC $FIXPATH_SRC_W -Fe$FIXPATH_BIN_W > $FIXPATH_DIR/fixpath1.log 2>&1
|
|
cd $CURDIR
|
|
|
|
if test ! -x $FIXPATH_BIN; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
cat $FIXPATH_DIR/fixpath1.log
|
|
as_fn_error $? "Could not create $FIXPATH_BIN" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath.exe works" >&5
|
|
$as_echo_n "checking if fixpath.exe works... " >&6; }
|
|
cd $FIXPATH_DIR
|
|
$FIXPATH $CC $FIXPATH_SRC -Fe$FIXPATH_DIR/fixpath2.exe \
|
|
> $FIXPATH_DIR/fixpath2.log 2>&1
|
|
cd $CURDIR
|
|
if test ! -x $FIXPATH_DIR/fixpath2.exe; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
cat $FIXPATH_DIR/fixpath2.log
|
|
as_fn_error $? "fixpath did not work!" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
|
|
FIXPATH_DETACH_FLAG="--detach"
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check if X11 is needed
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows || test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
# No X11 support on windows or macosx
|
|
NEEDS_LIB_X11=false
|
|
else
|
|
# All other instances need X11, even if building headless only, libawt still
|
|
# needs X11 headers.
|
|
NEEDS_LIB_X11=true
|
|
fi
|
|
|
|
# Check if cups is needed
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# Windows have a separate print system
|
|
NEEDS_LIB_CUPS=false
|
|
else
|
|
NEEDS_LIB_CUPS=true
|
|
fi
|
|
|
|
# A custom hook may have set this already
|
|
if test "x$NEEDS_LIB_FREETYPE" = "x"; then
|
|
NEEDS_LIB_FREETYPE=true
|
|
fi
|
|
|
|
# Check if alsa is needed
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
NEEDS_LIB_ALSA=true
|
|
else
|
|
NEEDS_LIB_ALSA=false
|
|
fi
|
|
|
|
# Check if ffi is needed
|
|
if [[ " $JVM_VARIANTS " =~ " zero " ]] || [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
NEEDS_LIB_FFI=true
|
|
else
|
|
NEEDS_LIB_FFI=false
|
|
fi
|
|
|
|
|
|
# statically link libstdc++ before C++ ABI is stablized on Linux unless
|
|
# dynamic build is configured on command line.
|
|
|
|
# Check whether --with-stdc++lib was given.
|
|
if test "${with_stdc__lib+set}" = set; then :
|
|
withval=$with_stdc__lib;
|
|
if test "x$with_stdc__lib" != xdynamic && test "x$with_stdc__lib" != xstatic \
|
|
&& test "x$with_stdc__lib" != xdefault; then
|
|
as_fn_error $? "Bad parameter value --with-stdc++lib=$with_stdc__lib!" "$LINENO" 5
|
|
fi
|
|
|
|
else
|
|
with_stdc__lib=default
|
|
|
|
fi
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xlinux; then
|
|
# Test if stdc++ can be linked statically.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5
|
|
$as_echo_n "checking if static link of stdc++ is possible... " >&6; }
|
|
STATIC_STDCXX_FLAGS="-static-libstdc++ -static-libgcc"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
OLD_LIBS="$LIBS"
|
|
LIBS="$STATIC_STDCXX_FLAGS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
return 0;
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
has_static_libstdcxx=yes
|
|
else
|
|
has_static_libstdcxx=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS="$OLD_LIBS"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5
|
|
$as_echo "$has_static_libstdcxx" >&6; }
|
|
|
|
if test "x$with_stdc__lib" = xstatic && test "x$has_static_libstdcxx" = xno; then
|
|
as_fn_error $? "Static linking of libstdc++ was not possible!" "$LINENO" 5
|
|
fi
|
|
|
|
# If dynamic was requested, it's available since it would fail above otherwise.
|
|
# If dynamic wasn't requested, go with static unless it isn't available.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5
|
|
$as_echo_n "checking how to link with libstdc++... " >&6; }
|
|
if test "x$with_stdc__lib" = xdynamic || test "x$has_static_libstdcxx" = xno \
|
|
|| [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5
|
|
$as_echo "dynamic" >&6; }
|
|
else
|
|
LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS $STATIC_STDCXX_FLAGS"
|
|
# Ideally, we should test stdc++ for the BUILD toolchain separately. For now
|
|
# just use the same setting as for the TARGET toolchain.
|
|
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS $STATIC_STDCXX_FLAGS"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5
|
|
$as_echo "static" >&6; }
|
|
fi
|
|
fi
|
|
|
|
# libCrun is the c++ runtime-library with SunStudio (roughly the equivalent of gcc's libstdc++.so)
|
|
if test "x$TOOLCHAIN_TYPE" = xsolstudio && test "x$LIBCXX" = x; then
|
|
LIBCXX="${SYSROOT}/usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libCrun.so.1"
|
|
fi
|
|
|
|
|
|
|
|
# Setup Windows runtime dlls
|
|
if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
|
|
|
|
|
|
# Check whether --with-msvcr-dll was given.
|
|
if test "${with_msvcr_dll+set}" = set; then :
|
|
withval=$with_msvcr_dll;
|
|
fi
|
|
|
|
|
|
if test "x$with_msvcr_dll" != x; then
|
|
# If given explicitly by user, do not probe. If not present, fail directly.
|
|
|
|
DLL_NAME="$MSVCR_NAME"
|
|
POSSIBLE_MSVC_DLL="$with_msvcr_dll"
|
|
METHOD="--with-msvcr-dll"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5
|
|
fi
|
|
MSVCR_DLL="$MSVC_DLL"
|
|
elif test "x$DEVKIT_MSVCR_DLL" != x; then
|
|
|
|
DLL_NAME="$MSVCR_NAME"
|
|
POSSIBLE_MSVC_DLL="$DEVKIT_MSVCR_DLL"
|
|
METHOD="devkit"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by devkit" "$LINENO" 5
|
|
fi
|
|
MSVCR_DLL="$MSVC_DLL"
|
|
else
|
|
|
|
DLL_NAME="${MSVCR_NAME}"
|
|
MSVC_DLL=
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Using well-known location from Visual Studio 10.0
|
|
if test "x$VCINSTALLDIR" != x; then
|
|
CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
|
|
|
|
windows_path="$CYGWIN_VC_INSTALL_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
CYGWIN_VC_INSTALL_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
CYGWIN_VC_INSTALL_DIR="$unix_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
|
|
else
|
|
POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
|
|
fi
|
|
$ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="well-known location in VCINSTALLDIR"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Check in the Boot JDK directory.
|
|
POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="well-known location in Boot JDK"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Look in the Windows system32 directory
|
|
CYGWIN_SYSTEMROOT="$SYSTEMROOT"
|
|
|
|
windows_path="$CYGWIN_SYSTEMROOT"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
CYGWIN_SYSTEMROOT="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
CYGWIN_SYSTEMROOT="$unix_path"
|
|
fi
|
|
|
|
POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="well-known location in SYSTEMROOT"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: If Visual Studio Express is installed, there is usually one with the debugger
|
|
if test "x$VS100COMNTOOLS" != x; then
|
|
CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
|
|
|
|
windows_path="$CYGWIN_VS_TOOLS_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
CYGWIN_VS_TOOLS_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
CYGWIN_VS_TOOLS_DIR="$unix_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
|
|
| $GREP -i /x64/ | $HEAD --lines 1`
|
|
else
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
|
|
| $GREP -i /x86/ | $HEAD --lines 1`
|
|
fi
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="search of VS100COMNTOOLS"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
|
|
# (This was the original behaviour; kept since it might turn something up)
|
|
if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
|
|
| $GREP x64 | $HEAD --lines 1`
|
|
else
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
|
|
| $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
|
|
if test "x$POSSIBLE_MSVC_DLL" = x; then
|
|
# We're grasping at straws now...
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
|
|
| $HEAD --lines 1`
|
|
fi
|
|
fi
|
|
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="search of VCINSTALLDIR"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
|
|
fi
|
|
|
|
MSVCR_DLL="$MSVC_DLL"
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-msvcp-dll was given.
|
|
if test "${with_msvcp_dll+set}" = set; then :
|
|
withval=$with_msvcp_dll;
|
|
fi
|
|
|
|
|
|
if test "x$MSVCP_NAME" != "x"; then
|
|
if test "x$with_msvcp_dll" != x; then
|
|
# If given explicitly by user, do not probe. If not present, fail directly.
|
|
|
|
DLL_NAME="$MSVCP_NAME"
|
|
POSSIBLE_MSVC_DLL="$with_msvcp_dll"
|
|
METHOD="--with-msvcp-dll"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5
|
|
fi
|
|
MSVCP_DLL="$MSVC_DLL"
|
|
elif test "x$DEVKIT_MSVCP_DLL" != x; then
|
|
|
|
DLL_NAME="$MSVCP_NAME"
|
|
POSSIBLE_MSVC_DLL="$DEVKIT_MSVCP_DLL"
|
|
METHOD="devkit"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by devkit" "$LINENO" 5
|
|
fi
|
|
MSVCP_DLL="$MSVC_DLL"
|
|
else
|
|
|
|
DLL_NAME="${MSVCP_NAME}"
|
|
MSVC_DLL=
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Using well-known location from Visual Studio 10.0
|
|
if test "x$VCINSTALLDIR" != x; then
|
|
CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
|
|
|
|
windows_path="$CYGWIN_VC_INSTALL_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
CYGWIN_VC_INSTALL_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
CYGWIN_VC_INSTALL_DIR="$unix_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
|
|
else
|
|
POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
|
|
fi
|
|
$ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="well-known location in VCINSTALLDIR"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Check in the Boot JDK directory.
|
|
POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="well-known location in Boot JDK"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Look in the Windows system32 directory
|
|
CYGWIN_SYSTEMROOT="$SYSTEMROOT"
|
|
|
|
windows_path="$CYGWIN_SYSTEMROOT"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
CYGWIN_SYSTEMROOT="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
CYGWIN_SYSTEMROOT="$unix_path"
|
|
fi
|
|
|
|
POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="well-known location in SYSTEMROOT"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: If Visual Studio Express is installed, there is usually one with the debugger
|
|
if test "x$VS100COMNTOOLS" != x; then
|
|
CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
|
|
|
|
windows_path="$CYGWIN_VS_TOOLS_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
CYGWIN_VS_TOOLS_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
CYGWIN_VS_TOOLS_DIR="$unix_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
|
|
| $GREP -i /x64/ | $HEAD --lines 1`
|
|
else
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
|
|
| $GREP -i /x86/ | $HEAD --lines 1`
|
|
fi
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="search of VS100COMNTOOLS"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
# Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
|
|
# (This was the original behaviour; kept since it might turn something up)
|
|
if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
|
|
| $GREP x64 | $HEAD --lines 1`
|
|
else
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
|
|
| $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
|
|
if test "x$POSSIBLE_MSVC_DLL" = x; then
|
|
# We're grasping at straws now...
|
|
POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
|
|
| $HEAD --lines 1`
|
|
fi
|
|
fi
|
|
|
|
|
|
DLL_NAME="$DLL_NAME"
|
|
POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
METHOD="search of VCINSTALLDIR"
|
|
if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
|
|
$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
|
|
|
|
# Need to check if the found msvcr is correct architecture
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
|
|
$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
|
|
MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
|
|
# on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH="PE32 executable"
|
|
else
|
|
CORRECT_MSVCR_ARCH="PE32+ executable"
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
|
|
CORRECT_MSVCR_ARCH=386
|
|
else
|
|
CORRECT_MSVCR_ARCH=x86-64
|
|
fi
|
|
fi
|
|
if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
|
|
$as_echo "ok" >&6; }
|
|
MSVC_DLL="$POSSIBLE_MSVC_DLL"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$MSVC_DLL" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$MSVC_DLL"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$MSVC_DLL"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
MSVC_DLL="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$MSVC_DLL"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
MSVC_DLL="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
|
|
$as_echo "$MSVC_DLL" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
|
|
$as_echo "incorrect, ignoring" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
|
|
$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$MSVC_DLL" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
|
|
$as_echo_n "checking for $DLL_NAME... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
|
|
fi
|
|
|
|
MSVCP_DLL="$MSVC_DLL"
|
|
fi
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if test "x$NEEDS_LIB_X11" = xfalse; then
|
|
if (test "x${with_x}" != x && test "x${with_x}" != xno); then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: X11 is not used, so --with-x is ignored" >&5
|
|
$as_echo "$as_me: WARNING: X11 is not used, so --with-x is ignored" >&2;}
|
|
fi
|
|
X_CFLAGS=
|
|
X_LIBS=
|
|
else
|
|
|
|
if test "x${with_x}" = xno; then
|
|
as_fn_error $? "It is not possible to disable the use of X11. Remove the --without-x option." "$LINENO" 5
|
|
fi
|
|
|
|
if test "x${with_x}" != x && test "x${with_x}" != xyes; then
|
|
# The user has specified a X11 base directory. Use it for includes and
|
|
# libraries, unless explicitly overridden.
|
|
if test "x$x_includes" = xNONE; then
|
|
x_includes="${with_x}/include"
|
|
fi
|
|
if test "x$x_libraries" = xNONE; then
|
|
x_libraries="${with_x}/lib"
|
|
fi
|
|
else
|
|
# Check if the user has specified sysroot, but not --with-x, --x-includes or --x-libraries.
|
|
# Make a simple check for the libraries at the sysroot, and setup --x-includes and
|
|
# --x-libraries for the sysroot, if that seems to be correct.
|
|
if test "x$SYSROOT" != "x"; then
|
|
if test "x$x_includes" = xNONE; then
|
|
if test -f "$SYSROOT/usr/X11R6/include/X11/Xlib.h"; then
|
|
x_includes="$SYSROOT/usr/X11R6/include"
|
|
elif test -f "$SYSROOT/usr/include/X11/Xlib.h"; then
|
|
x_includes="$SYSROOT/usr/include"
|
|
fi
|
|
fi
|
|
if test "x$x_libraries" = xNONE; then
|
|
if test -f "$SYSROOT/usr/X11R6/lib/libX11.so"; then
|
|
x_libraries="$SYSROOT/usr/X11R6/lib"
|
|
elif test -f "$SYSROOT/usr/lib64/libX11.so" && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
x_libraries="$SYSROOT/usr/lib64"
|
|
elif test -f "$SYSROOT/usr/lib/libX11.so"; then
|
|
x_libraries="$SYSROOT/usr/lib"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Now let autoconf do it's magic
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
|
|
$as_echo_n "checking for X... " >&6; }
|
|
|
|
|
|
# Check whether --with-x was given.
|
|
if test "${with_x+set}" = set; then :
|
|
withval=$with_x;
|
|
fi
|
|
|
|
# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
|
|
if test "x$with_x" = xno; then
|
|
# The user explicitly disabled X.
|
|
have_x=disabled
|
|
else
|
|
case $x_includes,$x_libraries in #(
|
|
*\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
|
|
*,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
# One or both of the vars are not set, and there is no cached value.
|
|
ac_x_includes=no ac_x_libraries=no
|
|
rm -f -r conftest.dir
|
|
if mkdir conftest.dir; then
|
|
cd conftest.dir
|
|
cat >Imakefile <<'_ACEOF'
|
|
incroot:
|
|
@echo incroot='${INCROOT}'
|
|
usrlibdir:
|
|
@echo usrlibdir='${USRLIBDIR}'
|
|
libdir:
|
|
@echo libdir='${LIBDIR}'
|
|
_ACEOF
|
|
if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then
|
|
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
|
|
for ac_var in incroot usrlibdir libdir; do
|
|
eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`"
|
|
done
|
|
# Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
|
|
for ac_extension in a so sl dylib la dll; do
|
|
if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" &&
|
|
test -f "$ac_im_libdir/libX11.$ac_extension"; then
|
|
ac_im_usrlibdir=$ac_im_libdir; break
|
|
fi
|
|
done
|
|
# Screen out bogus values from the imake configuration. They are
|
|
# bogus both because they are the default anyway, and because
|
|
# using them would break gcc on systems where it needs fixed includes.
|
|
case $ac_im_incroot in
|
|
/usr/include) ac_x_includes= ;;
|
|
*) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;;
|
|
esac
|
|
case $ac_im_usrlibdir in
|
|
/usr/lib | /usr/lib64 | /lib | /lib64) ;;
|
|
*) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;;
|
|
esac
|
|
fi
|
|
cd ..
|
|
rm -f -r conftest.dir
|
|
fi
|
|
|
|
# Standard set of common directories for X headers.
|
|
# Check X11 before X11Rn because it is often a symlink to the current release.
|
|
ac_x_header_dirs='
|
|
/usr/X11/include
|
|
/usr/X11R7/include
|
|
/usr/X11R6/include
|
|
/usr/X11R5/include
|
|
/usr/X11R4/include
|
|
|
|
/usr/include/X11
|
|
/usr/include/X11R7
|
|
/usr/include/X11R6
|
|
/usr/include/X11R5
|
|
/usr/include/X11R4
|
|
|
|
/usr/local/X11/include
|
|
/usr/local/X11R7/include
|
|
/usr/local/X11R6/include
|
|
/usr/local/X11R5/include
|
|
/usr/local/X11R4/include
|
|
|
|
/usr/local/include/X11
|
|
/usr/local/include/X11R7
|
|
/usr/local/include/X11R6
|
|
/usr/local/include/X11R5
|
|
/usr/local/include/X11R4
|
|
|
|
/usr/X386/include
|
|
/usr/x386/include
|
|
/usr/XFree86/include/X11
|
|
|
|
/usr/include
|
|
/usr/local/include
|
|
/usr/unsupported/include
|
|
/usr/athena/include
|
|
/usr/local/x11r5/include
|
|
/usr/lpp/Xamples/include
|
|
|
|
/usr/openwin/include
|
|
/usr/openwin/share/include'
|
|
|
|
if test "$ac_x_includes" = no; then
|
|
# Guess where to find include files, by looking for Xlib.h.
|
|
# First, try using that file with no special directory specified.
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <X11/Xlib.h>
|
|
_ACEOF
|
|
if ac_fn_cxx_try_cpp "$LINENO"; then :
|
|
# We can compile using X headers with no special include directory.
|
|
ac_x_includes=
|
|
else
|
|
for ac_dir in $ac_x_header_dirs; do
|
|
if test -r "$ac_dir/X11/Xlib.h"; then
|
|
ac_x_includes=$ac_dir
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
rm -f conftest.err conftest.i conftest.$ac_ext
|
|
fi # $ac_x_includes = no
|
|
|
|
if test "$ac_x_libraries" = no; then
|
|
# Check for the libraries.
|
|
# See if we find them without any special options.
|
|
# Don't add to $LIBS permanently.
|
|
ac_save_LIBS=$LIBS
|
|
LIBS="-lX11 $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <X11/Xlib.h>
|
|
int
|
|
main ()
|
|
{
|
|
XrmInitialize ()
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
LIBS=$ac_save_LIBS
|
|
# We can link X programs with no special library path.
|
|
ac_x_libraries=
|
|
else
|
|
LIBS=$ac_save_LIBS
|
|
for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
|
|
do
|
|
# Don't even attempt the hair of trying to link an X program!
|
|
for ac_extension in a so sl dylib la dll; do
|
|
if test -r "$ac_dir/libX11.$ac_extension"; then
|
|
ac_x_libraries=$ac_dir
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
fi # $ac_x_libraries = no
|
|
|
|
case $ac_x_includes,$ac_x_libraries in #(
|
|
no,* | *,no | *\'*)
|
|
# Didn't find X, or a directory has "'" in its name.
|
|
ac_cv_have_x="have_x=no";; #(
|
|
*)
|
|
# Record where we found X for the cache.
|
|
ac_cv_have_x="have_x=yes\
|
|
ac_x_includes='$ac_x_includes'\
|
|
ac_x_libraries='$ac_x_libraries'"
|
|
esac
|
|
fi
|
|
;; #(
|
|
*) have_x=yes;;
|
|
esac
|
|
eval "$ac_cv_have_x"
|
|
fi # $with_x != no
|
|
|
|
if test "$have_x" != yes; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
|
|
$as_echo "$have_x" >&6; }
|
|
no_x=yes
|
|
else
|
|
# If each of the values was on the command line, it overrides each guess.
|
|
test "x$x_includes" = xNONE && x_includes=$ac_x_includes
|
|
test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
|
|
# Update the cache value to reflect the command line values.
|
|
ac_cv_have_x="have_x=yes\
|
|
ac_x_includes='$x_includes'\
|
|
ac_x_libraries='$x_libraries'"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
|
|
$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
|
|
fi
|
|
|
|
if test "$no_x" = yes; then
|
|
# Not all programs may use this symbol, but it does not hurt to define it.
|
|
|
|
$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h
|
|
|
|
X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
|
|
else
|
|
if test -n "$x_includes"; then
|
|
X_CFLAGS="$X_CFLAGS -I$x_includes"
|
|
fi
|
|
|
|
# It would also be nice to do this for all -L options, not just this one.
|
|
if test -n "$x_libraries"; then
|
|
X_LIBS="$X_LIBS -L$x_libraries"
|
|
# For Solaris; some versions of Sun CC require a space after -R and
|
|
# others require no space. Words are not sufficient . . . .
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
|
|
$as_echo_n "checking whether -R must be followed by a space... " >&6; }
|
|
ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries"
|
|
ac_xsave_cxx_werror_flag=$ac_cxx_werror_flag
|
|
ac_cxx_werror_flag=yes
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
X_LIBS="$X_LIBS -R$x_libraries"
|
|
else
|
|
LIBS="$ac_xsave_LIBS -R $x_libraries"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
X_LIBS="$X_LIBS -R $x_libraries"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
|
|
$as_echo "neither works" >&6; }
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
ac_cxx_werror_flag=$ac_xsave_cxx_werror_flag
|
|
LIBS=$ac_xsave_LIBS
|
|
fi
|
|
|
|
# Check for system-dependent libraries X programs must link with.
|
|
# Do this before checking for the system-independent R6 libraries
|
|
# (-lICE), since we may need -lsocket or whatever for X linking.
|
|
|
|
if test "$ISC" = yes; then
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet"
|
|
else
|
|
# Martyn Johnson says this is needed for Ultrix, if the X
|
|
# libraries were built with DECnet support. And Karl Berry says
|
|
# the Alpha needs dnet_stub (dnet does not exist).
|
|
ac_xsave_LIBS="$LIBS"; LIBS="$LIBS $X_LIBS -lX11"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char XOpenDisplay ();
|
|
int
|
|
main ()
|
|
{
|
|
return XOpenDisplay ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
|
|
$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; }
|
|
if ${ac_cv_lib_dnet_dnet_ntoa+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-ldnet $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char dnet_ntoa ();
|
|
int
|
|
main ()
|
|
{
|
|
return dnet_ntoa ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_dnet_dnet_ntoa=yes
|
|
else
|
|
ac_cv_lib_dnet_dnet_ntoa=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
|
|
$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
|
|
if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes; then :
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"
|
|
fi
|
|
|
|
if test $ac_cv_lib_dnet_dnet_ntoa = no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
|
|
$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; }
|
|
if ${ac_cv_lib_dnet_stub_dnet_ntoa+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-ldnet_stub $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char dnet_ntoa ();
|
|
int
|
|
main ()
|
|
{
|
|
return dnet_ntoa ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_dnet_stub_dnet_ntoa=yes
|
|
else
|
|
ac_cv_lib_dnet_stub_dnet_ntoa=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
|
|
$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
|
|
if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes; then :
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS="$ac_xsave_LIBS"
|
|
|
|
# msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT,
|
|
# to get the SysV transport functions.
|
|
# Chad R. Larson says the Pyramis MIS-ES running DC/OSx (SVR4)
|
|
# needs -lnsl.
|
|
# The nsl library prevents programs from opening the X display
|
|
# on Irix 5.2, according to T.E. Dickey.
|
|
# The functions gethostbyname, getservbyname, and inet_addr are
|
|
# in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking.
|
|
ac_fn_cxx_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
|
|
if test "x$ac_cv_func_gethostbyname" = xyes; then :
|
|
|
|
fi
|
|
|
|
if test $ac_cv_func_gethostbyname = no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
|
|
$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
|
|
if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lnsl $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char gethostbyname ();
|
|
int
|
|
main ()
|
|
{
|
|
return gethostbyname ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_nsl_gethostbyname=yes
|
|
else
|
|
ac_cv_lib_nsl_gethostbyname=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
|
|
$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
|
|
if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
|
|
fi
|
|
|
|
if test $ac_cv_lib_nsl_gethostbyname = no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
|
|
$as_echo_n "checking for gethostbyname in -lbsd... " >&6; }
|
|
if ${ac_cv_lib_bsd_gethostbyname+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lbsd $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char gethostbyname ();
|
|
int
|
|
main ()
|
|
{
|
|
return gethostbyname ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_bsd_gethostbyname=yes
|
|
else
|
|
ac_cv_lib_bsd_gethostbyname=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
|
|
$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; }
|
|
if test "x$ac_cv_lib_bsd_gethostbyname" = xyes; then :
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd"
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
# lieder@skyler.mavd.honeywell.com says without -lsocket,
|
|
# socket/setsockopt and other routines are undefined under SCO ODT
|
|
# 2.0. But -lsocket is broken on IRIX 5.2 (and is not necessary
|
|
# on later versions), says Simon Leinen: it contains gethostby*
|
|
# variants that don't use the name server (or something). -lsocket
|
|
# must be given before -lnsl if both are needed. We assume that
|
|
# if connect needs -lnsl, so does gethostbyname.
|
|
ac_fn_cxx_check_func "$LINENO" "connect" "ac_cv_func_connect"
|
|
if test "x$ac_cv_func_connect" = xyes; then :
|
|
|
|
fi
|
|
|
|
if test $ac_cv_func_connect = no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
|
|
$as_echo_n "checking for connect in -lsocket... " >&6; }
|
|
if ${ac_cv_lib_socket_connect+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char connect ();
|
|
int
|
|
main ()
|
|
{
|
|
return connect ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_socket_connect=yes
|
|
else
|
|
ac_cv_lib_socket_connect=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
|
|
$as_echo "$ac_cv_lib_socket_connect" >&6; }
|
|
if test "x$ac_cv_lib_socket_connect" = xyes; then :
|
|
X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
|
|
fi
|
|
|
|
fi
|
|
|
|
# Guillermo Gomez says -lposix is necessary on A/UX.
|
|
ac_fn_cxx_check_func "$LINENO" "remove" "ac_cv_func_remove"
|
|
if test "x$ac_cv_func_remove" = xyes; then :
|
|
|
|
fi
|
|
|
|
if test $ac_cv_func_remove = no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
|
|
$as_echo_n "checking for remove in -lposix... " >&6; }
|
|
if ${ac_cv_lib_posix_remove+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lposix $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char remove ();
|
|
int
|
|
main ()
|
|
{
|
|
return remove ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_posix_remove=yes
|
|
else
|
|
ac_cv_lib_posix_remove=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
|
|
$as_echo "$ac_cv_lib_posix_remove" >&6; }
|
|
if test "x$ac_cv_lib_posix_remove" = xyes; then :
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
|
|
fi
|
|
|
|
fi
|
|
|
|
# BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
|
|
ac_fn_cxx_check_func "$LINENO" "shmat" "ac_cv_func_shmat"
|
|
if test "x$ac_cv_func_shmat" = xyes; then :
|
|
|
|
fi
|
|
|
|
if test $ac_cv_func_shmat = no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
|
|
$as_echo_n "checking for shmat in -lipc... " >&6; }
|
|
if ${ac_cv_lib_ipc_shmat+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lipc $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char shmat ();
|
|
int
|
|
main ()
|
|
{
|
|
return shmat ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_ipc_shmat=yes
|
|
else
|
|
ac_cv_lib_ipc_shmat=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
|
|
$as_echo "$ac_cv_lib_ipc_shmat" >&6; }
|
|
if test "x$ac_cv_lib_ipc_shmat" = xyes; then :
|
|
X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc"
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
# Check for libraries that X11R6 Xt/Xaw programs need.
|
|
ac_save_LDFLAGS=$LDFLAGS
|
|
test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries"
|
|
# SM needs ICE to (dynamically) link under SunOS 4.x (so we have to
|
|
# check for ICE first), but we must link in the order -lSM -lICE or
|
|
# we get undefined symbols. So assume we have SM if we have ICE.
|
|
# These have to be linked with before -lX11, unlike the other
|
|
# libraries we check for below, so use a different variable.
|
|
# John Interrante, Karl Berry
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
|
|
$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; }
|
|
if ${ac_cv_lib_ICE_IceConnectionNumber+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lICE $X_EXTRA_LIBS $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char IceConnectionNumber ();
|
|
int
|
|
main ()
|
|
{
|
|
return IceConnectionNumber ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_ICE_IceConnectionNumber=yes
|
|
else
|
|
ac_cv_lib_ICE_IceConnectionNumber=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
|
|
$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
|
|
if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes; then :
|
|
X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"
|
|
fi
|
|
|
|
LDFLAGS=$ac_save_LDFLAGS
|
|
|
|
fi
|
|
|
|
|
|
# AC_PATH_XTRA creates X_LIBS and sometimes adds -R flags. When cross compiling
|
|
# this doesn't make sense so we remove it.
|
|
if test "x$COMPILE_TYPE" = xcross; then
|
|
X_LIBS=`$ECHO $X_LIBS | $SED 's/-R \{0,1\}[^ ]*//g'`
|
|
fi
|
|
|
|
if test "x$no_x" = xyes; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# x11 is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=x11
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find X11 libraries. $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
|
OPENWIN_HOME="/usr/openwin"
|
|
X_CFLAGS="-I$SYSROOT$OPENWIN_HOME/include -I$SYSROOT$OPENWIN_HOME/include/X11/extensions"
|
|
X_LIBS="-L$SYSROOT$OPENWIN_HOME/lib$OPENJDK_TARGET_CPU_ISADIR \
|
|
-R$OPENWIN_HOME/lib$OPENJDK_TARGET_CPU_ISADIR"
|
|
fi
|
|
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
OLD_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $SYSROOT_CFLAGS $X_CFLAGS"
|
|
|
|
# Need to include Xlib.h and Xutil.h to avoid "present but cannot be compiled" warnings on Solaris 10
|
|
for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h X11/Intrinsic.h
|
|
do :
|
|
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
|
|
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "
|
|
# include <X11/Xlib.h>
|
|
# include <X11/Xutil.h>
|
|
|
|
|
|
"
|
|
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
|
|
_ACEOF
|
|
X11_HEADERS_OK=yes
|
|
else
|
|
X11_HEADERS_OK=no; break
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
if test "x$X11_HEADERS_OK" = xno; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# x11 is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=x11
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find all X11 headers (shape.h Xrender.h XTest.h Intrinsic.h). $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
|
|
# If XLinearGradient isn't available in Xrender.h, signal that it needs to be
|
|
# defined in libawt_xawt.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if XlinearGradient is defined in Xrender.h" >&5
|
|
$as_echo_n "checking if XlinearGradient is defined in Xrender.h... " >&6; }
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <X11/extensions/Xrender.h>
|
|
int
|
|
main ()
|
|
{
|
|
XLinearGradient x;
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_compile "$LINENO"; then :
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
X_CFLAGS="$X_CFLAGS -DSOLARIS10_NO_XRENDER_STRUCTS"
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
|
|
CFLAGS="$OLD_CFLAGS"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
fi # NEEDS_LIB_X11
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-cups was given.
|
|
if test "${with_cups+set}" = set; then :
|
|
withval=$with_cups;
|
|
fi
|
|
|
|
|
|
# Check whether --with-cups-include was given.
|
|
if test "${with_cups_include+set}" = set; then :
|
|
withval=$with_cups_include;
|
|
fi
|
|
|
|
|
|
if test "x$NEEDS_LIB_CUPS" = xfalse; then
|
|
if (test "x${with_cups}" != x && test "x${with_cups}" != xno) || \
|
|
(test "x${with_cups_include}" != x && test "x${with_cups_include}" != xno); then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups[-*] is ignored" >&5
|
|
$as_echo "$as_me: WARNING: cups not used, so --with-cups[-*] is ignored" >&2;}
|
|
fi
|
|
CUPS_CFLAGS=
|
|
else
|
|
CUPS_FOUND=no
|
|
|
|
if test "x${with_cups}" = xno || test "x${with_cups_include}" = xno; then
|
|
as_fn_error $? "It is not possible to disable the use of cups. Remove the --without-cups option." "$LINENO" 5
|
|
fi
|
|
|
|
if test "x${with_cups}" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
|
|
$as_echo_n "checking for cups headers... " >&6; }
|
|
if test -s "${with_cups}/include/cups/cups.h"; then
|
|
CUPS_CFLAGS="-I${with_cups}/include"
|
|
CUPS_FOUND=yes
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
|
|
$as_echo "$CUPS_FOUND" >&6; }
|
|
else
|
|
as_fn_error $? "Can't find 'include/cups/cups.h' under ${with_cups} given with the --with-cups option." "$LINENO" 5
|
|
fi
|
|
fi
|
|
if test "x${with_cups_include}" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
|
|
$as_echo_n "checking for cups headers... " >&6; }
|
|
if test -s "${with_cups_include}/cups/cups.h"; then
|
|
CUPS_CFLAGS="-I${with_cups_include}"
|
|
CUPS_FOUND=yes
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
|
|
$as_echo "$CUPS_FOUND" >&6; }
|
|
else
|
|
as_fn_error $? "Can't find 'cups/cups.h' under ${with_cups_include} given with the --with-cups-include option." "$LINENO" 5
|
|
fi
|
|
fi
|
|
if test "x$CUPS_FOUND" = xno; then
|
|
# Are the cups headers installed in the default /usr/include location?
|
|
for ac_header in cups/cups.h cups/ppd.h
|
|
do :
|
|
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
|
|
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
|
|
_ACEOF
|
|
|
|
CUPS_FOUND=yes
|
|
CUPS_CFLAGS=
|
|
DEFAULT_CUPS=yes
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
fi
|
|
if test "x$CUPS_FOUND" = xno; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# cups is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=cups
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find cups! $HELP_MSG " "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-freetype was given.
|
|
if test "${with_freetype+set}" = set; then :
|
|
withval=$with_freetype;
|
|
fi
|
|
|
|
|
|
# Check whether --with-freetype-include was given.
|
|
if test "${with_freetype_include+set}" = set; then :
|
|
withval=$with_freetype_include;
|
|
fi
|
|
|
|
|
|
# Check whether --with-freetype-lib was given.
|
|
if test "${with_freetype_lib+set}" = set; then :
|
|
withval=$with_freetype_lib;
|
|
fi
|
|
|
|
|
|
# Check whether --with-freetype-src was given.
|
|
if test "${with_freetype_src+set}" = set; then :
|
|
withval=$with_freetype_src;
|
|
fi
|
|
|
|
# Check whether --enable-freetype-bundling was given.
|
|
if test "${enable_freetype_bundling+set}" = set; then :
|
|
enableval=$enable_freetype_bundling;
|
|
fi
|
|
|
|
|
|
# Check whether --with-freetype-license was given.
|
|
if test "${with_freetype_license+set}" = set; then :
|
|
withval=$with_freetype_license;
|
|
fi
|
|
|
|
|
|
# Need to specify explicitly since it needs to be overridden on some versions of macosx
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_CFLAGS=
|
|
FREETYPE_LIBS=
|
|
FREETYPE_BUNDLE_LIB_PATH=
|
|
|
|
if test "x$NEEDS_LIB_FREETYPE" = xfalse; then
|
|
if (test "x$with_freetype" != x && test "x$with_freetype" != xno) || \
|
|
(test "x$with_freetype_include" != x && test "x$with_freetype_include" != xno) || \
|
|
(test "x$with_freetype_lib" != x && test "x$with_freetype_lib" != xno) || \
|
|
(test "x$with_freetype_src" != x && test "x$with_freetype_src" != xno); then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: freetype not used, so --with-freetype[-*] is ignored" >&5
|
|
$as_echo "$as_me: WARNING: freetype not used, so --with-freetype[-*] is ignored" >&2;}
|
|
fi
|
|
if (test "x$enable_freetype_bundling" != x && test "x$enable_freetype_bundling" != xno); then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: freetype not used, so --enable-freetype-bundling is ignored" >&5
|
|
$as_echo "$as_me: WARNING: freetype not used, so --enable-freetype-bundling is ignored" >&2;}
|
|
fi
|
|
else
|
|
# freetype is needed to build; go get it!
|
|
|
|
BUNDLE_FREETYPE="$enable_freetype_bundling"
|
|
|
|
if test "x$with_freetype_src" != x; then
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# Try to build freetype if --with-freetype-src was given on Windows
|
|
|
|
FREETYPE_SRC_PATH="$with_freetype_src"
|
|
BUILD_FREETYPE=yes
|
|
|
|
# Check if the freetype sources are acessible..
|
|
if ! test -d $FREETYPE_SRC_PATH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&5
|
|
$as_echo "$as_me: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&2;}
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
# ..and contain a vc2010 project file
|
|
vcxproj_path="$FREETYPE_SRC_PATH/builds/windows/vc2010/freetype.vcxproj"
|
|
if test "x$BUILD_FREETYPE" = xyes && ! test -s $vcxproj_path; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&5
|
|
$as_echo "$as_me: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&2;}
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
# Now check if configure found a version of 'msbuild.exe'
|
|
if test "x$BUILD_FREETYPE" = xyes && test "x$MSBUILD" == x ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&5
|
|
$as_echo "$as_me: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&2;}
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
|
|
# Ready to go..
|
|
if test "x$BUILD_FREETYPE" = xyes; then
|
|
# msbuild requires trailing slashes for output directories
|
|
freetype_lib_path="$FREETYPE_SRC_PATH/lib$OPENJDK_TARGET_CPU_BITS/"
|
|
freetype_lib_path_unix="$freetype_lib_path"
|
|
freetype_obj_path="$FREETYPE_SRC_PATH/obj$OPENJDK_TARGET_CPU_BITS/"
|
|
|
|
unix_path="$vcxproj_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
vcxproj_path="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
vcxproj_path="$windows_path"
|
|
fi
|
|
|
|
|
|
unix_path="$freetype_lib_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
freetype_lib_path="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
freetype_lib_path="$windows_path"
|
|
fi
|
|
|
|
|
|
unix_path="$freetype_obj_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
freetype_obj_path="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
freetype_obj_path="$windows_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
freetype_platform=x64
|
|
else
|
|
freetype_platform=win32
|
|
fi
|
|
|
|
# The original freetype project file is for VS 2010 (i.e. 'v100'),
|
|
# so we have to adapt the toolset if building with any other toolsed (i.e. SDK).
|
|
# Currently 'PLATFORM_TOOLSET' is set in 'TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT'/
|
|
# 'TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT' in toolchain_windows.m4
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&5
|
|
$as_echo "$as_me: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&6;}
|
|
|
|
# First we try to build the freetype.dll
|
|
$ECHO -e "@echo off\n"\
|
|
"$MSBUILD $vcxproj_path "\
|
|
"/p:PlatformToolset=$PLATFORM_TOOLSET "\
|
|
"/p:Configuration=\"Release Multithreaded\" "\
|
|
"/p:Platform=$freetype_platform "\
|
|
"/p:ConfigurationType=DynamicLibrary "\
|
|
"/p:TargetName=freetype "\
|
|
"/p:OutDir=\"$freetype_lib_path\" "\
|
|
"/p:IntDir=\"$freetype_obj_path\" > freetype.log" > freetype.bat
|
|
cmd /c freetype.bat
|
|
|
|
if test -s "$freetype_lib_path_unix/freetype.dll"; then
|
|
# If that succeeds we also build freetype.lib
|
|
$ECHO -e "@echo off\n"\
|
|
"$MSBUILD $vcxproj_path "\
|
|
"/p:PlatformToolset=$PLATFORM_TOOLSET "\
|
|
"/p:Configuration=\"Release Multithreaded\" "\
|
|
"/p:Platform=$freetype_platform "\
|
|
"/p:ConfigurationType=StaticLibrary "\
|
|
"/p:TargetName=freetype "\
|
|
"/p:OutDir=\"$freetype_lib_path\" "\
|
|
"/p:IntDir=\"$freetype_obj_path\" >> freetype.log" > freetype.bat
|
|
cmd /c freetype.bat
|
|
|
|
if test -s "$freetype_lib_path_unix/freetype.lib"; then
|
|
# Once we build both, lib and dll, set freetype lib and include path appropriately
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_SRC_PATH/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$freetype_lib_path_unix"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compiling freetype sources succeeded! (see freetype.log for build results)" >&5
|
|
$as_echo "$as_me: Compiling freetype sources succeeded! (see freetype.log for build results)" >&6;}
|
|
else
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
else
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$BUILD_FREETYPE" = xyes; then
|
|
# Okay, we built it. Check that it works.
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
METHOD="--with-freetype-src"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
as_fn_error $? "Can not use the built freetype at location given by --with-freetype-src" "$LINENO" 5
|
|
fi
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: User specified --with-freetype-src but building freetype failed. (see freetype.log for build results)" >&5
|
|
$as_echo "$as_me: User specified --with-freetype-src but building freetype failed. (see freetype.log for build results)" >&6;}
|
|
as_fn_error $? "Consider building freetype manually and using --with-freetype instead." "$LINENO" 5
|
|
fi
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-freetype-src is currently only supported on Windows - ignoring" >&5
|
|
$as_echo "$as_me: WARNING: --with-freetype-src is currently only supported on Windows - ignoring" >&2;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$with_freetype" != x || test "x$with_freetype_include" != x || test "x$with_freetype_lib" != x; then
|
|
# User has specified settings
|
|
|
|
if test "x$BUNDLE_FREETYPE" = x; then
|
|
# If not specified, default is to bundle freetype
|
|
BUNDLE_FREETYPE=yes
|
|
fi
|
|
|
|
if test "x$with_freetype" != x; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$with_freetype/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$with_freetype/lib"
|
|
fi
|
|
|
|
# Allow --with-freetype-lib and --with-freetype-include to override
|
|
if test "x$with_freetype_include" != x; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$with_freetype_include"
|
|
fi
|
|
if test "x$with_freetype_lib" != x; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$with_freetype_lib"
|
|
fi
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x && test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
# Okay, we got it. Check that it works.
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
METHOD="--with-freetype"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
as_fn_error $? "Can not find or use freetype at location given by --with-freetype" "$LINENO" 5
|
|
fi
|
|
else
|
|
# User specified only one of lib or include. This is an error.
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" = x ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: User specified --with-freetype-lib but not --with-freetype-include" >&5
|
|
$as_echo "$as_me: User specified --with-freetype-lib but not --with-freetype-include" >&6;}
|
|
as_fn_error $? "Need both freetype lib and include paths. Consider using --with-freetype instead." "$LINENO" 5
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: User specified --with-freetype-include but not --with-freetype-lib" >&5
|
|
$as_echo "$as_me: User specified --with-freetype-include but not --with-freetype-lib" >&6;}
|
|
as_fn_error $? "Need both freetype lib and include paths. Consider using --with-freetype instead." "$LINENO" 5
|
|
fi
|
|
fi
|
|
else
|
|
# User did not specify settings, but we need freetype. Try to locate it.
|
|
|
|
if test "x$BUNDLE_FREETYPE" = x; then
|
|
# If not specified, default is to bundle freetype only on windows
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
BUNDLE_FREETYPE=yes
|
|
else
|
|
BUNDLE_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
# If we have a sysroot, assume that's where we are supposed to look and skip pkg-config.
|
|
if test "x$SYSROOT" = x; then
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
# Check modules using pkg-config, but only if we have it (ugly output results otherwise)
|
|
if test "x$PKG_CONFIG" != x; then
|
|
|
|
pkg_failed=no
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FREETYPE" >&5
|
|
$as_echo_n "checking for FREETYPE... " >&6; }
|
|
|
|
if test -n "$FREETYPE_CFLAGS"; then
|
|
pkg_cv_FREETYPE_CFLAGS="$FREETYPE_CFLAGS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_FREETYPE_CFLAGS=`$PKG_CONFIG --cflags "freetype2" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
if test -n "$FREETYPE_LIBS"; then
|
|
pkg_cv_FREETYPE_LIBS="$FREETYPE_LIBS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_FREETYPE_LIBS=`$PKG_CONFIG --libs "freetype2" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
|
|
|
|
|
|
if test $pkg_failed = yes; then
|
|
|
|
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
|
|
_pkg_short_errors_supported=yes
|
|
else
|
|
_pkg_short_errors_supported=no
|
|
fi
|
|
if test $_pkg_short_errors_supported = yes; then
|
|
FREETYPE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "freetype2" 2>&1`
|
|
else
|
|
FREETYPE_PKG_ERRORS=`$PKG_CONFIG --print-errors "freetype2" 2>&1`
|
|
fi
|
|
# Put the nasty error message in config.log where it belongs
|
|
echo "$FREETYPE_PKG_ERRORS" >&5
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
FOUND_FREETYPE=no
|
|
elif test $pkg_failed = untried; then
|
|
FOUND_FREETYPE=no
|
|
else
|
|
FREETYPE_CFLAGS=$pkg_cv_FREETYPE_CFLAGS
|
|
FREETYPE_LIBS=$pkg_cv_FREETYPE_LIBS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
FOUND_FREETYPE=yes
|
|
fi
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# On solaris, pkg_check adds -lz to freetype libs, which isn't necessary for us.
|
|
FREETYPE_LIBS=`$ECHO $FREETYPE_LIBS | $SED 's/-lz//g'`
|
|
# 64-bit libs for Solaris x86 are installed in the amd64 subdirectory, change lib to lib/amd64
|
|
if test "x$OPENJDK_TARGET_OS" = xsolaris && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
|
FREETYPE_LIBS=`$ECHO $FREETYPE_LIBS | $SED 's?/lib?/lib/amd64?g'`
|
|
fi
|
|
# PKG_CHECK_MODULES will set FREETYPE_CFLAGS and _LIBS, but we don't get a lib path for bundling.
|
|
if test "x$BUNDLE_FREETYPE" = xyes; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype using pkg-config, but ignoring since we can not bundle that" >&5
|
|
$as_echo "$as_me: Found freetype using pkg-config, but ignoring since we can not bundle that" >&6;}
|
|
FOUND_FREETYPE=no
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype" >&5
|
|
$as_echo_n "checking for freetype... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (using pkg-config)" >&5
|
|
$as_echo "yes (using pkg-config)" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
# Check in well-known locations
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
FREETYPE_BASE_DIR="$PROGRAMFILES/GnuWin32"
|
|
|
|
windows_path="$FREETYPE_BASE_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
FREETYPE_BASE_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
FREETYPE_BASE_DIR="$unix_path"
|
|
fi
|
|
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
FREETYPE_BASE_DIR="$ProgramW6432/GnuWin32"
|
|
|
|
windows_path="$FREETYPE_BASE_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
FREETYPE_BASE_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
FREETYPE_BASE_DIR="$unix_path"
|
|
fi
|
|
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
FREETYPE_BASE_DIR="$HOME/freetype"
|
|
|
|
windows_path="$FREETYPE_BASE_DIR"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
FREETYPE_BASE_DIR="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
FREETYPE_BASE_DIR="$unix_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib64"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
else
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib32"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
if test "x$FOUND_FREETYPE" != xyes && test -d $FREETYPE_BASE_DIR \
|
|
&& test -s "$FREETYPE_BASE_DIR/builds/windows/vc2010/freetype.vcxproj" && test "x$MSBUILD" != x; then
|
|
# Source is available, as a last resort try to build freetype in default location
|
|
|
|
FREETYPE_SRC_PATH="$FREETYPE_BASE_DIR"
|
|
BUILD_FREETYPE=yes
|
|
|
|
# Check if the freetype sources are acessible..
|
|
if ! test -d $FREETYPE_SRC_PATH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&5
|
|
$as_echo "$as_me: WARNING: --with-freetype-src specified, but can not find path \"$FREETYPE_SRC_PATH\" - ignoring --with-freetype-src" >&2;}
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
# ..and contain a vc2010 project file
|
|
vcxproj_path="$FREETYPE_SRC_PATH/builds/windows/vc2010/freetype.vcxproj"
|
|
if test "x$BUILD_FREETYPE" = xyes && ! test -s $vcxproj_path; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&5
|
|
$as_echo "$as_me: WARNING: Can not find project file $vcxproj_path (you may try a newer freetype version) - ignoring --with-freetype-src" >&2;}
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
# Now check if configure found a version of 'msbuild.exe'
|
|
if test "x$BUILD_FREETYPE" = xyes && test "x$MSBUILD" == x ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&5
|
|
$as_echo "$as_me: WARNING: Can not find an msbuild.exe executable (you may try to install .NET 4.0) - ignoring --with-freetype-src" >&2;}
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
|
|
# Ready to go..
|
|
if test "x$BUILD_FREETYPE" = xyes; then
|
|
# msbuild requires trailing slashes for output directories
|
|
freetype_lib_path="$FREETYPE_SRC_PATH/lib$OPENJDK_TARGET_CPU_BITS/"
|
|
freetype_lib_path_unix="$freetype_lib_path"
|
|
freetype_obj_path="$FREETYPE_SRC_PATH/obj$OPENJDK_TARGET_CPU_BITS/"
|
|
|
|
unix_path="$vcxproj_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
vcxproj_path="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
vcxproj_path="$windows_path"
|
|
fi
|
|
|
|
|
|
unix_path="$freetype_lib_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
freetype_lib_path="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
freetype_lib_path="$windows_path"
|
|
fi
|
|
|
|
|
|
unix_path="$freetype_obj_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
windows_path=`$CYGPATH -m "$unix_path"`
|
|
freetype_obj_path="$windows_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
windows_path=`cmd //c echo $unix_path`
|
|
freetype_obj_path="$windows_path"
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
freetype_platform=x64
|
|
else
|
|
freetype_platform=win32
|
|
fi
|
|
|
|
# The original freetype project file is for VS 2010 (i.e. 'v100'),
|
|
# so we have to adapt the toolset if building with any other toolsed (i.e. SDK).
|
|
# Currently 'PLATFORM_TOOLSET' is set in 'TOOLCHAIN_CHECK_POSSIBLE_VISUAL_STUDIO_ROOT'/
|
|
# 'TOOLCHAIN_CHECK_POSSIBLE_WIN_SDK_ROOT' in toolchain_windows.m4
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&5
|
|
$as_echo "$as_me: Trying to compile freetype sources with PlatformToolset=$PLATFORM_TOOLSET to $freetype_lib_path_unix ..." >&6;}
|
|
|
|
# First we try to build the freetype.dll
|
|
$ECHO -e "@echo off\n"\
|
|
"$MSBUILD $vcxproj_path "\
|
|
"/p:PlatformToolset=$PLATFORM_TOOLSET "\
|
|
"/p:Configuration=\"Release Multithreaded\" "\
|
|
"/p:Platform=$freetype_platform "\
|
|
"/p:ConfigurationType=DynamicLibrary "\
|
|
"/p:TargetName=freetype "\
|
|
"/p:OutDir=\"$freetype_lib_path\" "\
|
|
"/p:IntDir=\"$freetype_obj_path\" > freetype.log" > freetype.bat
|
|
cmd /c freetype.bat
|
|
|
|
if test -s "$freetype_lib_path_unix/freetype.dll"; then
|
|
# If that succeeds we also build freetype.lib
|
|
$ECHO -e "@echo off\n"\
|
|
"$MSBUILD $vcxproj_path "\
|
|
"/p:PlatformToolset=$PLATFORM_TOOLSET "\
|
|
"/p:Configuration=\"Release Multithreaded\" "\
|
|
"/p:Platform=$freetype_platform "\
|
|
"/p:ConfigurationType=StaticLibrary "\
|
|
"/p:TargetName=freetype "\
|
|
"/p:OutDir=\"$freetype_lib_path\" "\
|
|
"/p:IntDir=\"$freetype_obj_path\" >> freetype.log" > freetype.bat
|
|
cmd /c freetype.bat
|
|
|
|
if test -s "$freetype_lib_path_unix/freetype.lib"; then
|
|
# Once we build both, lib and dll, set freetype lib and include path appropriately
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_SRC_PATH/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$freetype_lib_path_unix"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compiling freetype sources succeeded! (see freetype.log for build results)" >&5
|
|
$as_echo "$as_me: Compiling freetype sources succeeded! (see freetype.log for build results)" >&6;}
|
|
else
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
else
|
|
BUILD_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib64"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
else
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib32"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
else
|
|
FREETYPE_BASE_DIR="$SYSROOT/usr"
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
FREETYPE_BASE_DIR="$SYSROOT/usr/X11"
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
FREETYPE_BASE_DIR="$SYSROOT/usr/local"
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
# Due to changes in OSX 10.11 XQuartz now installs to /opt/X11
|
|
FREETYPE_BASE_DIR="$SYSROOT/opt/X11"
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
FREETYPE_BASE_DIR="$SYSROOT/usr"
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib/$OPENJDK_TARGET_CPU-linux-gnu"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
else
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib/i386-linux-gnu"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$FREETYPE_BASE_DIR/include"
|
|
POTENTIAL_FREETYPE_LIB_PATH="$FREETYPE_BASE_DIR/lib32"
|
|
METHOD="well-known location"
|
|
|
|
# Let's start with an optimistic view of the world :-)
|
|
FOUND_FREETYPE=yes
|
|
|
|
# First look for the canonical freetype main include file ft2build.h.
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Oh no! Let's try in the freetype2 directory. This is needed at least at Mac OS X Yosemite.
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH/freetype2"
|
|
if ! test -s "$POTENTIAL_FREETYPE_INCLUDE_PATH/ft2build.h"; then
|
|
# Fail.
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
# Include file found, let's continue the sanity check.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
|
|
$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
|
|
|
|
# Reset to default value
|
|
FREETYPE_BASE_NAME=freetype
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
|
|
if test "x$OPENJDK_TARGET_OS" = xmacosx \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH/${LIBRARY_PREFIX}freetype.6${SHARED_LIBRARY_SUFFIX}"; then
|
|
# On Mac OS X Yosemite, the symlink from libfreetype.dylib to libfreetype.6.dylib disappeared. Check
|
|
# for the .6 version explicitly.
|
|
FREETYPE_BASE_NAME=freetype.6
|
|
FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Compensating for missing symlink by using version 6 explicitly" >&5
|
|
$as_echo "$as_me: Compensating for missing symlink by using version 6 explicitly" >&6;}
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
else
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On Windows, we will need both .lib and .dll file.
|
|
if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&5
|
|
$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/${FREETYPE_BASE_NAME}.lib. Ignoring location." >&6;}
|
|
FOUND_FREETYPE=no
|
|
fi
|
|
elif test "x$OPENJDK_TARGET_OS" = xsolaris \
|
|
&& test -s "$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR/$FREETYPE_LIB_NAME"; then
|
|
# Found lib in isa dir, use that instead.
|
|
POTENTIAL_FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH$OPENJDK_TARGET_CPU_ISADIR"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&5
|
|
$as_echo "$as_me: Rewriting to use $POTENTIAL_FREETYPE_LIB_PATH instead" >&6;}
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$FOUND_FREETYPE" = xyes; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$POTENTIAL_FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
POTENTIAL_FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
|
|
$as_echo_n "checking for freetype includes... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
|
|
$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
|
|
FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
|
|
$as_echo_n "checking for freetype libraries... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
|
|
$as_echo "$FREETYPE_LIB_PATH" >&6; }
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi # end check in well-known locations
|
|
|
|
if test "x$FOUND_FREETYPE" != xyes; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# freetype is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=freetype
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find freetype! $HELP_MSG " "$LINENO" 5
|
|
fi
|
|
fi # end user specified settings
|
|
|
|
# Set FREETYPE_CFLAGS, _LIBS and _LIB_PATH from include and lib dir.
|
|
if test "x$FREETYPE_CFLAGS" = x; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FREETYPE_INCLUDE_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$FREETYPE_INCLUDE_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FREETYPE_INCLUDE_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$FREETYPE_INCLUDE_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
FREETYPE_INCLUDE_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$FREETYPE_INCLUDE_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
FREETYPE_INCLUDE_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test -d $FREETYPE_INCLUDE_PATH/freetype2/freetype; then
|
|
FREETYPE_CFLAGS="-I$FREETYPE_INCLUDE_PATH/freetype2 -I$FREETYPE_INCLUDE_PATH"
|
|
else
|
|
FREETYPE_CFLAGS="-I$FREETYPE_INCLUDE_PATH"
|
|
fi
|
|
fi
|
|
|
|
if test "x$FREETYPE_LIBS" = x; then
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FREETYPE_LIB_PATH" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$FREETYPE_LIB_PATH"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FREETYPE_LIB_PATH" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$FREETYPE_LIB_PATH"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
FREETYPE_LIB_PATH="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$FREETYPE_LIB_PATH"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
FREETYPE_LIB_PATH="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
FREETYPE_LIBS="$FREETYPE_LIB_PATH/$FREETYPE_BASE_NAME.lib"
|
|
else
|
|
FREETYPE_LIBS="-L$FREETYPE_LIB_PATH -l$FREETYPE_BASE_NAME"
|
|
fi
|
|
fi
|
|
|
|
# Try to compile it
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can compile and link with freetype" >&5
|
|
$as_echo_n "checking if we can compile and link with freetype... " >&6; }
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
PREV_CXXCFLAGS="$CXXFLAGS"
|
|
PREV_LIBS="$LIBS"
|
|
PREV_CXX="$CXX"
|
|
CXXFLAGS="$CXXFLAGS $FREETYPE_CFLAGS"
|
|
LIBS="$LIBS $FREETYPE_LIBS"
|
|
CXX="$FIXPATH $CXX"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
#include<ft2build.h>
|
|
#include FT_FREETYPE_H
|
|
int main () {
|
|
FT_Init_FreeType(NULL);
|
|
return 0;
|
|
}
|
|
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
|
|
else
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Could not compile and link with freetype. This might be a 32/64-bit mismatch." >&5
|
|
$as_echo "$as_me: Could not compile and link with freetype. This might be a 32/64-bit mismatch." >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using FREETYPE_CFLAGS=$FREETYPE_CFLAGS and FREETYPE_LIBS=$FREETYPE_LIBS" >&5
|
|
$as_echo "$as_me: Using FREETYPE_CFLAGS=$FREETYPE_CFLAGS and FREETYPE_LIBS=$FREETYPE_LIBS" >&6;}
|
|
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# freetype is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=freetype
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
|
|
as_fn_error $? "Can not continue without freetype. $HELP_MSG" "$LINENO" 5
|
|
|
|
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
CXXCFLAGS="$PREV_CXXFLAGS"
|
|
LIBS="$PREV_LIBS"
|
|
CXX="$PREV_CXX"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should bundle freetype" >&5
|
|
$as_echo_n "checking if we should bundle freetype... " >&6; }
|
|
if test "x$BUNDLE_FREETYPE" = xyes; then
|
|
FREETYPE_BUNDLE_LIB_PATH="$FREETYPE_LIB_PATH"
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUNDLE_FREETYPE" >&5
|
|
$as_echo "$BUNDLE_FREETYPE" >&6; }
|
|
|
|
fi # end freetype needed
|
|
|
|
FREETYPE_LICENSE=""
|
|
if test "x$with_freetype_license" = "xyes"; then
|
|
as_fn_error $? "--with-freetype-license must have a value" "$LINENO" 5
|
|
elif test "x$with_freetype_license" != "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype license" >&5
|
|
$as_echo_n "checking for freetype license... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_freetype_license" >&5
|
|
$as_echo "$with_freetype_license" >&6; }
|
|
FREETYPE_LICENSE="$with_freetype_license"
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$FREETYPE_LICENSE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$FREETYPE_LICENSE"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LICENSE, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FREETYPE_LICENSE, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of FREETYPE_LICENSE" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
FREETYPE_LICENSE="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LICENSE to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting FREETYPE_LICENSE to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$FREETYPE_LICENSE"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
FREETYPE_LICENSE="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LICENSE to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting FREETYPE_LICENSE to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$FREETYPE_LICENSE"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LICENSE, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of FREETYPE_LICENSE, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of FREETYPE_LICENSE, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
FREETYPE_LICENSE="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
FREETYPE_LICENSE="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test ! -f "$FREETYPE_LICENSE"; then
|
|
as_fn_error $? "$FREETYPE_LICENSE cannot be found" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-alsa was given.
|
|
if test "${with_alsa+set}" = set; then :
|
|
withval=$with_alsa;
|
|
fi
|
|
|
|
|
|
# Check whether --with-alsa-include was given.
|
|
if test "${with_alsa_include+set}" = set; then :
|
|
withval=$with_alsa_include;
|
|
fi
|
|
|
|
|
|
# Check whether --with-alsa-lib was given.
|
|
if test "${with_alsa_lib+set}" = set; then :
|
|
withval=$with_alsa_lib;
|
|
fi
|
|
|
|
|
|
if test "x$NEEDS_LIB_ALSA" = xfalse; then
|
|
if (test "x${with_alsa}" != x && test "x${with_alsa}" != xno) || \
|
|
(test "x${with_alsa_include}" != x && test "x${with_alsa_include}" != xno) || \
|
|
(test "x${with_alsa_lib}" != x && test "x${with_alsa_lib}" != xno); then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa[-*] is ignored" >&5
|
|
$as_echo "$as_me: WARNING: alsa not used, so --with-alsa[-*] is ignored" >&2;}
|
|
fi
|
|
ALSA_CFLAGS=
|
|
ALSA_LIBS=
|
|
else
|
|
ALSA_FOUND=no
|
|
|
|
if test "x${with_alsa}" = xno || test "x${with_alsa_include}" = xno || test "x${with_alsa_lib}" = xno; then
|
|
as_fn_error $? "It is not possible to disable the use of alsa. Remove the --without-alsa option." "$LINENO" 5
|
|
fi
|
|
|
|
if test "x${with_alsa}" != x; then
|
|
ALSA_LIBS="-L${with_alsa}/lib -lasound"
|
|
ALSA_CFLAGS="-I${with_alsa}/include"
|
|
ALSA_FOUND=yes
|
|
fi
|
|
if test "x${with_alsa_include}" != x; then
|
|
ALSA_CFLAGS="-I${with_alsa_include}"
|
|
ALSA_FOUND=yes
|
|
fi
|
|
if test "x${with_alsa_lib}" != x; then
|
|
ALSA_LIBS="-L${with_alsa_lib} -lasound"
|
|
ALSA_FOUND=yes
|
|
fi
|
|
# Do not try pkg-config if we have a sysroot set.
|
|
if test "x$SYSROOT" = x; then
|
|
if test "x$ALSA_FOUND" = xno; then
|
|
|
|
pkg_failed=no
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5
|
|
$as_echo_n "checking for ALSA... " >&6; }
|
|
|
|
if test -n "$ALSA_CFLAGS"; then
|
|
pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "alsa") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
if test -n "$ALSA_LIBS"; then
|
|
pkg_cv_ALSA_LIBS="$ALSA_LIBS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "alsa") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
|
|
|
|
|
|
if test $pkg_failed = yes; then
|
|
|
|
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
|
|
_pkg_short_errors_supported=yes
|
|
else
|
|
_pkg_short_errors_supported=no
|
|
fi
|
|
if test $_pkg_short_errors_supported = yes; then
|
|
ALSA_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "alsa" 2>&1`
|
|
else
|
|
ALSA_PKG_ERRORS=`$PKG_CONFIG --print-errors "alsa" 2>&1`
|
|
fi
|
|
# Put the nasty error message in config.log where it belongs
|
|
echo "$ALSA_PKG_ERRORS" >&5
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
ALSA_FOUND=no
|
|
elif test $pkg_failed = untried; then
|
|
ALSA_FOUND=no
|
|
else
|
|
ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS
|
|
ALSA_LIBS=$pkg_cv_ALSA_LIBS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
ALSA_FOUND=yes
|
|
fi
|
|
fi
|
|
fi
|
|
if test "x$ALSA_FOUND" = xno; then
|
|
for ac_header in alsa/asoundlib.h
|
|
do :
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default"
|
|
if test "x$ac_cv_header_alsa_asoundlib_h" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_ALSA_ASOUNDLIB_H 1
|
|
_ACEOF
|
|
|
|
ALSA_FOUND=yes
|
|
ALSA_CFLAGS=-Iignoreme
|
|
ALSA_LIBS=-lasound
|
|
DEFAULT_ALSA=yes
|
|
|
|
else
|
|
ALSA_FOUND=no
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
fi
|
|
if test "x$ALSA_FOUND" = xno; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# alsa is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=alsa
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find alsa! $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-libffi was given.
|
|
if test "${with_libffi+set}" = set; then :
|
|
withval=$with_libffi;
|
|
fi
|
|
|
|
|
|
# Check whether --with-libffi-include was given.
|
|
if test "${with_libffi_include+set}" = set; then :
|
|
withval=$with_libffi_include;
|
|
fi
|
|
|
|
|
|
# Check whether --with-libffi-lib was given.
|
|
if test "${with_libffi_lib+set}" = set; then :
|
|
withval=$with_libffi_lib;
|
|
fi
|
|
|
|
# Check whether --enable-libffi-bundling was given.
|
|
if test "${enable_libffi_bundling+set}" = set; then :
|
|
enableval=$enable_libffi_bundling;
|
|
fi
|
|
|
|
|
|
if test "x$NEEDS_LIB_FFI" = xfalse; then
|
|
if (test "x${with_libffi}" != x && test "x${with_libffi}" != xno) || \
|
|
(test "x${with_libffi_include}" != x && test "x${with_libffi_include}" != xno) || \
|
|
(test "x${with_libffi_lib}" != x && test "x${with_libffi_lib}" != xno); then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: libffi not used, so --with-libffi[-*] is ignored" >&5
|
|
$as_echo "$as_me: WARNING: libffi not used, so --with-libffi[-*] is ignored" >&2;}
|
|
fi
|
|
LIBFFI_CFLAGS=
|
|
LIBFFI_LIBS=
|
|
else
|
|
LIBFFI_FOUND=no
|
|
|
|
if test "x${with_libffi}" = xno || test "x${with_libffi_include}" = xno || test "x${with_libffi_lib}" = xno; then
|
|
as_fn_error $? "It is not possible to disable the use of libffi. Remove the --without-libffi option." "$LINENO" 5
|
|
fi
|
|
|
|
if test "x${with_libffi}" != x; then
|
|
LIBFFI_LIB_PATH="${with_libffi}/lib"
|
|
LIBFFI_LIBS="-L${with_libffi}/lib -lffi"
|
|
LIBFFI_CFLAGS="-I${with_libffi}/include"
|
|
LIBFFI_FOUND=yes
|
|
fi
|
|
if test "x${with_libffi_include}" != x; then
|
|
LIBFFI_CFLAGS="-I${with_libffi_include}"
|
|
LIBFFI_FOUND=yes
|
|
fi
|
|
if test "x${with_libffi_lib}" != x; then
|
|
LIBFFI_LIB_PATH="${with_libffi_lib}"
|
|
LIBFFI_LIBS="-L${with_libffi_lib} -lffi"
|
|
LIBFFI_FOUND=yes
|
|
fi
|
|
# Do not try pkg-config if we have a sysroot set.
|
|
if test "x$SYSROOT" = x; then
|
|
if test "x$LIBFFI_FOUND" = xno; then
|
|
# Figure out LIBFFI_CFLAGS and LIBFFI_LIBS
|
|
|
|
pkg_failed=no
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBFFI" >&5
|
|
$as_echo_n "checking for LIBFFI... " >&6; }
|
|
|
|
if test -n "$LIBFFI_CFLAGS"; then
|
|
pkg_cv_LIBFFI_CFLAGS="$LIBFFI_CFLAGS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "libffi") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_LIBFFI_CFLAGS=`$PKG_CONFIG --cflags "libffi" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
if test -n "$LIBFFI_LIBS"; then
|
|
pkg_cv_LIBFFI_LIBS="$LIBFFI_LIBS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "libffi") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_LIBFFI_LIBS=`$PKG_CONFIG --libs "libffi" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
|
|
|
|
|
|
if test $pkg_failed = yes; then
|
|
|
|
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
|
|
_pkg_short_errors_supported=yes
|
|
else
|
|
_pkg_short_errors_supported=no
|
|
fi
|
|
if test $_pkg_short_errors_supported = yes; then
|
|
LIBFFI_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libffi" 2>&1`
|
|
else
|
|
LIBFFI_PKG_ERRORS=`$PKG_CONFIG --print-errors "libffi" 2>&1`
|
|
fi
|
|
# Put the nasty error message in config.log where it belongs
|
|
echo "$LIBFFI_PKG_ERRORS" >&5
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
LIBFFI_FOUND=no
|
|
elif test $pkg_failed = untried; then
|
|
LIBFFI_FOUND=no
|
|
else
|
|
LIBFFI_CFLAGS=$pkg_cv_LIBFFI_CFLAGS
|
|
LIBFFI_LIBS=$pkg_cv_LIBFFI_LIBS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
LIBFFI_FOUND=yes
|
|
fi
|
|
fi
|
|
fi
|
|
if test "x$LIBFFI_FOUND" = xno; then
|
|
for ac_header in ffi.h
|
|
do :
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "ffi.h" "ac_cv_header_ffi_h" "$ac_includes_default"
|
|
if test "x$ac_cv_header_ffi_h" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_FFI_H 1
|
|
_ACEOF
|
|
|
|
LIBFFI_FOUND=yes
|
|
LIBFFI_CFLAGS=
|
|
LIBFFI_LIBS=-lffi
|
|
|
|
else
|
|
LIBFFI_FOUND=no
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
fi
|
|
if test "x$LIBFFI_FOUND" = xno; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# ffi is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=ffi
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Could not find libffi! $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libffi works" >&5
|
|
$as_echo_n "checking if libffi works... " >&6; }
|
|
ac_ext=c
|
|
ac_cpp='$CPP $CPPFLAGS'
|
|
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_c_compiler_gnu
|
|
|
|
OLD_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $LIBFFI_CFLAGS"
|
|
OLD_LIBS="$LIBS"
|
|
LIBS="$LIBS $LIBFFI_LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
#include <ffi.h>
|
|
int
|
|
main ()
|
|
{
|
|
|
|
ffi_call(NULL, NULL, NULL, NULL);
|
|
return 0;
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_c_try_link "$LINENO"; then :
|
|
LIBFFI_WORKS=yes
|
|
else
|
|
LIBFFI_WORKS=no
|
|
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
CFLAGS="$OLD_CFLAGS"
|
|
LIBS="$OLD_LIBS"
|
|
ac_ext=cpp
|
|
ac_cpp='$CXXCPP $CPPFLAGS'
|
|
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
|
|
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
|
|
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBFFI_WORKS" >&5
|
|
$as_echo "$LIBFFI_WORKS" >&6; }
|
|
|
|
if test "x$LIBFFI_WORKS" = xno; then
|
|
|
|
# Print a helpful message on how to acquire the necessary build dependency.
|
|
# ffi is the help tag: freetype, cups, alsa etc
|
|
MISSING_DEPENDENCY=ffi
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
cygwin_help $MISSING_DEPENDENCY
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
msys_help $MISSING_DEPENDENCY
|
|
else
|
|
PKGHANDLER_COMMAND=
|
|
|
|
case $PKGHANDLER in
|
|
apt-get)
|
|
apt_help $MISSING_DEPENDENCY ;;
|
|
yum)
|
|
yum_help $MISSING_DEPENDENCY ;;
|
|
brew)
|
|
brew_help $MISSING_DEPENDENCY ;;
|
|
port)
|
|
port_help $MISSING_DEPENDENCY ;;
|
|
pkgutil)
|
|
pkgutil_help $MISSING_DEPENDENCY ;;
|
|
pkgadd)
|
|
pkgadd_help $MISSING_DEPENDENCY ;;
|
|
esac
|
|
|
|
if test "x$PKGHANDLER_COMMAND" != x; then
|
|
HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
|
|
fi
|
|
fi
|
|
|
|
as_fn_error $? "Found libffi but could not link and compile with it. $HELP_MSG" "$LINENO" 5
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libffi should be bundled" >&5
|
|
$as_echo_n "checking if libffi should be bundled... " >&6; }
|
|
if test "x$enable_libffi_bundling" = "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
ENABLE_LIBFFI_BUNDLING=false
|
|
elif test "x$enable_libffi_bundling" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
ENABLE_LIBFFI_BUNDLING=false
|
|
elif test "x$enable_libffi_bundling" = "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
ENABLE_LIBFFI_BUNDLING=true
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-libffi-bundling" "$LINENO" 5
|
|
fi
|
|
|
|
# Find the libffi.so.X to bundle
|
|
if test "x${ENABLE_LIBFFI_BUNDLING}" = "xtrue"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libffi lib file location" >&5
|
|
$as_echo_n "checking for libffi lib file location... " >&6; }
|
|
if test "x${LIBFFI_LIB_PATH}" != x; then
|
|
if test -e ${LIBFFI_LIB_PATH}/libffi.so.?; then
|
|
LIBFFI_LIB_FILE="${LIBFFI_LIB_PATH}/libffi.so.?"
|
|
else
|
|
as_fn_error $? "Could not locate libffi.so.? for bundling in ${LIBFFI_LIB_PATH}" "$LINENO" 5
|
|
fi
|
|
else
|
|
# If we don't have an explicit path, look in a few obvious places
|
|
if test "x${OPENJDK_TARGET_CPU}" = "xx86"; then
|
|
if test -e ${SYSROOT}/usr/lib/libffi.so.? ; then
|
|
LIBFFI_LIB_FILE="${SYSROOT}/usr/lib/libffi.so.?"
|
|
elif test -e ${SYSROOT}/usr/lib/i386-linux-gnu/libffi.so.? ; then
|
|
LIBFFI_LIB_FILE="${SYSROOT}/usr/lib/i386-linux-gnu/libffi.so.?"
|
|
else
|
|
as_fn_error $? "Could not locate libffi.so.? for bundling" "$LINENO" 5
|
|
fi
|
|
elif test "x${OPENJDK_TARGET_CPU}" = "xx86_64"; then
|
|
if test -e ${SYSROOT}/usr/lib64/libffi.so.? ; then
|
|
LIBFFI_LIB_FILE="${SYSROOT}/usr/lib64/libffi.so.?"
|
|
elif test -e ${SYSROOT}/usr/lib/x86_64-linux-gnu/libffi.so.? ; then
|
|
LIBFFI_LIB_FILE="${SYSROOT}/usr/lib/x86_64-linux-gnu/libffi.so.?"
|
|
else
|
|
as_fn_error $? "Could not locate libffi.so.? for bundling" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Fallback on the default /usr/lib dir
|
|
if test -e ${SYSROOT}/usr/lib/libffi.so.? ; then
|
|
LIBFFI_LIB_FILE="${SYSROOT}/usr/lib/libffi.so.?"
|
|
else
|
|
as_fn_error $? "Could not locate libffi.so.? for bundling" "$LINENO" 5
|
|
fi
|
|
fi
|
|
fi
|
|
# Make sure the wildcard is evaluated
|
|
LIBFFI_LIB_FILE="$(ls ${LIBFFI_LIB_FILE})"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${LIBFFI_LIB_FILE}" >&5
|
|
$as_echo "${LIBFFI_LIB_FILE}" >&6; }
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
# Extract the first word of "llvm-config", so it can be a program name with args.
|
|
set dummy llvm-config; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_prog_LLVM_CONFIG+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
if test -n "$LLVM_CONFIG"; then
|
|
ac_cv_prog_LLVM_CONFIG="$LLVM_CONFIG" # Let the user override the test.
|
|
else
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_prog_LLVM_CONFIG="llvm-config"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
fi
|
|
fi
|
|
LLVM_CONFIG=$ac_cv_prog_LLVM_CONFIG
|
|
if test -n "$LLVM_CONFIG"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
|
|
$as_echo "$LLVM_CONFIG" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
if test "x$LLVM_CONFIG" != xllvm-config; then
|
|
as_fn_error $? "llvm-config not found in $PATH." "$LINENO" 5
|
|
fi
|
|
|
|
llvm_components="jit mcjit engine nativecodegen native"
|
|
unset LLVM_CFLAGS
|
|
for flag in $("$LLVM_CONFIG" --cxxflags); do
|
|
if echo "${flag}" | grep -q '^-[ID]'; then
|
|
if test "${flag}" != "-D_DEBUG" ; then
|
|
if test "${LLVM_CFLAGS}" != "" ; then
|
|
LLVM_CFLAGS="${LLVM_CFLAGS} "
|
|
fi
|
|
LLVM_CFLAGS="${LLVM_CFLAGS}${flag}"
|
|
fi
|
|
fi
|
|
done
|
|
llvm_version=$("${LLVM_CONFIG}" --version | $SED 's/\.//; s/svn.*//')
|
|
LLVM_CFLAGS="${LLVM_CFLAGS} -DSHARK_LLVM_VERSION=${llvm_version}"
|
|
|
|
unset LLVM_LDFLAGS
|
|
for flag in $("${LLVM_CONFIG}" --ldflags); do
|
|
if echo "${flag}" | grep -q '^-L'; then
|
|
if test "${LLVM_LDFLAGS}" != ""; then
|
|
LLVM_LDFLAGS="${LLVM_LDFLAGS} "
|
|
fi
|
|
LLVM_LDFLAGS="${LLVM_LDFLAGS}${flag}"
|
|
fi
|
|
done
|
|
|
|
unset LLVM_LIBS
|
|
for flag in $("${LLVM_CONFIG}" --libs ${llvm_components}); do
|
|
if echo "${flag}" | grep -q '^-l'; then
|
|
if test "${LLVM_LIBS}" != ""; then
|
|
LLVM_LIBS="${LLVM_LIBS} "
|
|
fi
|
|
LLVM_LIBS="${LLVM_LIBS}${flag}"
|
|
fi
|
|
done
|
|
|
|
# Due to https://llvm.org/bugs/show_bug.cgi?id=16902, llvm does not
|
|
# always properly detect -ltinfo
|
|
LLVM_LIBS="${LLVM_LIBS} -ltinfo"
|
|
|
|
|
|
|
|
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-libjpeg was given.
|
|
if test "${with_libjpeg+set}" = set; then :
|
|
withval=$with_libjpeg;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for which libjpeg to use" >&5
|
|
$as_echo_n "checking for which libjpeg to use... " >&6; }
|
|
# default is bundled
|
|
DEFAULT_LIBJPEG=bundled
|
|
# if user didn't specify, use DEFAULT_LIBJPEG
|
|
if test "x${with_libjpeg}" = "x"; then
|
|
with_libjpeg=${DEFAULT_LIBJPEG}
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_libjpeg}" >&5
|
|
$as_echo "${with_libjpeg}" >&6; }
|
|
|
|
if test "x${with_libjpeg}" = "xbundled"; then
|
|
USE_EXTERNAL_LIBJPEG=false
|
|
elif test "x${with_libjpeg}" = "xsystem"; then
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "jpeglib.h" "ac_cv_header_jpeglib_h" "$ac_includes_default"
|
|
if test "x$ac_cv_header_jpeglib_h" = xyes; then :
|
|
|
|
else
|
|
as_fn_error $? "--with-libjpeg=system specified, but jpeglib.h not found!" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for jpeg_CreateDecompress in -ljpeg" >&5
|
|
$as_echo_n "checking for jpeg_CreateDecompress in -ljpeg... " >&6; }
|
|
if ${ac_cv_lib_jpeg_jpeg_CreateDecompress+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-ljpeg $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char jpeg_CreateDecompress ();
|
|
int
|
|
main ()
|
|
{
|
|
return jpeg_CreateDecompress ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_jpeg_jpeg_CreateDecompress=yes
|
|
else
|
|
ac_cv_lib_jpeg_jpeg_CreateDecompress=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_jpeg_CreateDecompress" >&5
|
|
$as_echo "$ac_cv_lib_jpeg_jpeg_CreateDecompress" >&6; }
|
|
if test "x$ac_cv_lib_jpeg_jpeg_CreateDecompress" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_LIBJPEG 1
|
|
_ACEOF
|
|
|
|
LIBS="-ljpeg $LIBS"
|
|
|
|
else
|
|
as_fn_error $? "--with-libjpeg=system specified, but no libjpeg found" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
USE_EXTERNAL_LIBJPEG=true
|
|
else
|
|
as_fn_error $? "Invalid use of --with-libjpeg: ${with_libjpeg}, use 'system' or 'bundled'" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-giflib was given.
|
|
if test "${with_giflib+set}" = set; then :
|
|
withval=$with_giflib;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for which giflib to use" >&5
|
|
$as_echo_n "checking for which giflib to use... " >&6; }
|
|
# default is bundled
|
|
DEFAULT_GIFLIB=bundled
|
|
# if user didn't specify, use DEFAULT_GIFLIB
|
|
if test "x${with_giflib}" = "x"; then
|
|
with_giflib=${DEFAULT_GIFLIB}
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_giflib}" >&5
|
|
$as_echo "${with_giflib}" >&6; }
|
|
|
|
if test "x${with_giflib}" = "xbundled"; then
|
|
USE_EXTERNAL_LIBGIF=false
|
|
elif test "x${with_giflib}" = "xsystem"; then
|
|
ac_fn_cxx_check_header_mongrel "$LINENO" "gif_lib.h" "ac_cv_header_gif_lib_h" "$ac_includes_default"
|
|
if test "x$ac_cv_header_gif_lib_h" = xyes; then :
|
|
|
|
else
|
|
as_fn_error $? "--with-giflib=system specified, but gif_lib.h not found!" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DGifGetCode in -lgif" >&5
|
|
$as_echo_n "checking for DGifGetCode in -lgif... " >&6; }
|
|
if ${ac_cv_lib_gif_DGifGetCode+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lgif $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char DGifGetCode ();
|
|
int
|
|
main ()
|
|
{
|
|
return DGifGetCode ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_gif_DGifGetCode=yes
|
|
else
|
|
ac_cv_lib_gif_DGifGetCode=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_DGifGetCode" >&5
|
|
$as_echo "$ac_cv_lib_gif_DGifGetCode" >&6; }
|
|
if test "x$ac_cv_lib_gif_DGifGetCode" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_LIBGIF 1
|
|
_ACEOF
|
|
|
|
LIBS="-lgif $LIBS"
|
|
|
|
else
|
|
as_fn_error $? "--with-giflib=system specified, but no giflib found!" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
USE_EXTERNAL_LIBGIF=true
|
|
else
|
|
as_fn_error $? "Invalid value of --with-giflib: ${with_giflib}, use 'system' or 'bundled'" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-libpng was given.
|
|
if test "${with_libpng+set}" = set; then :
|
|
withval=$with_libpng;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for which libpng to use" >&5
|
|
$as_echo_n "checking for which libpng to use... " >&6; }
|
|
|
|
# default is bundled
|
|
DEFAULT_LIBPNG=bundled
|
|
# if user didn't specify, use DEFAULT_LIBPNG
|
|
if test "x${with_libpng}" = "x"; then
|
|
with_libpng=${DEFAULT_LIBPNG}
|
|
fi
|
|
|
|
if test "x${with_libpng}" = "xbundled"; then
|
|
USE_EXTERNAL_LIBPNG=false
|
|
PNG_CFLAGS=""
|
|
PNG_LIBS=""
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
|
|
$as_echo "bundled" >&6; }
|
|
elif test "x${with_libpng}" = "xsystem"; then
|
|
|
|
pkg_failed=no
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PNG" >&5
|
|
$as_echo_n "checking for PNG... " >&6; }
|
|
|
|
if test -n "$PNG_CFLAGS"; then
|
|
pkg_cv_PNG_CFLAGS="$PNG_CFLAGS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpng\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "libpng") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_PNG_CFLAGS=`$PKG_CONFIG --cflags "libpng" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
if test -n "$PNG_LIBS"; then
|
|
pkg_cv_PNG_LIBS="$PNG_LIBS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpng\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "libpng") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_PNG_LIBS=`$PKG_CONFIG --libs "libpng" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
|
|
|
|
|
|
if test $pkg_failed = yes; then
|
|
|
|
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
|
|
_pkg_short_errors_supported=yes
|
|
else
|
|
_pkg_short_errors_supported=no
|
|
fi
|
|
if test $_pkg_short_errors_supported = yes; then
|
|
PNG_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libpng" 2>&1`
|
|
else
|
|
PNG_PKG_ERRORS=`$PKG_CONFIG --print-errors "libpng" 2>&1`
|
|
fi
|
|
# Put the nasty error message in config.log where it belongs
|
|
echo "$PNG_PKG_ERRORS" >&5
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
LIBPNG_FOUND=no
|
|
elif test $pkg_failed = untried; then
|
|
LIBPNG_FOUND=no
|
|
else
|
|
PNG_CFLAGS=$pkg_cv_PNG_CFLAGS
|
|
PNG_LIBS=$pkg_cv_PNG_LIBS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
LIBPNG_FOUND=yes
|
|
fi
|
|
if test "x${LIBPNG_FOUND}" = "xyes"; then
|
|
# PKG_CHECK_MODULES will set PNG_CFLAGS and PNG_LIBS
|
|
USE_EXTERNAL_LIBPNG=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
|
|
$as_echo "system" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
|
|
$as_echo "system not found" >&6; }
|
|
as_fn_error $? "--with-libpng=system specified, but no libpng found!" "$LINENO" 5
|
|
fi
|
|
else
|
|
as_fn_error $? "Invalid value of --with-libpng: ${with_libpng}, use 'system' or 'bundled'" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-zlib was given.
|
|
if test "${with_zlib+set}" = set; then :
|
|
withval=$with_zlib;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5
|
|
$as_echo_n "checking for compress in -lz... " >&6; }
|
|
if ${ac_cv_lib_z_compress+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lz $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char compress ();
|
|
int
|
|
main ()
|
|
{
|
|
return compress ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_z_compress=yes
|
|
else
|
|
ac_cv_lib_z_compress=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5
|
|
$as_echo "$ac_cv_lib_z_compress" >&6; }
|
|
if test "x$ac_cv_lib_z_compress" = xyes; then :
|
|
ZLIB_FOUND=yes
|
|
else
|
|
ZLIB_FOUND=no
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5
|
|
$as_echo_n "checking for which zlib to use... " >&6; }
|
|
|
|
DEFAULT_ZLIB=system
|
|
if test "x$OPENJDK_TARGET_OS" = xwindows; then
|
|
# On windows default is bundled...on others default is system
|
|
DEFAULT_ZLIB=bundled
|
|
fi
|
|
|
|
if test "x${ZLIB_FOUND}" != "xyes"; then
|
|
# If we don't find any system...set default to bundled
|
|
DEFAULT_ZLIB=bundled
|
|
fi
|
|
|
|
# If user didn't specify, use DEFAULT_ZLIB
|
|
if test "x${with_zlib}" = "x"; then
|
|
with_zlib=${DEFAULT_ZLIB}
|
|
fi
|
|
|
|
if test "x${with_zlib}" = "xbundled"; then
|
|
USE_EXTERNAL_LIBZ=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
|
|
$as_echo "bundled" >&6; }
|
|
elif test "x${with_zlib}" = "xsystem"; then
|
|
if test "x${ZLIB_FOUND}" = "xyes"; then
|
|
USE_EXTERNAL_LIBZ=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
|
|
$as_echo "system" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
|
|
$as_echo "system not found" >&6; }
|
|
as_fn_error $? "--with-zlib=system specified, but no zlib found!" "$LINENO" 5
|
|
fi
|
|
else
|
|
as_fn_error $? "Invalid value for --with-zlib: ${with_zlib}, use 'system' or 'bundled'" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Check whether --with-lcms was given.
|
|
if test "${with_lcms+set}" = set; then :
|
|
withval=$with_lcms;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for which lcms to use" >&5
|
|
$as_echo_n "checking for which lcms to use... " >&6; }
|
|
|
|
DEFAULT_LCMS=bundled
|
|
# If user didn't specify, use DEFAULT_LCMS
|
|
if test "x${with_lcms}" = "x"; then
|
|
with_lcms=${DEFAULT_LCMS}
|
|
fi
|
|
|
|
if test "x${with_lcms}" = "xbundled"; then
|
|
USE_EXTERNAL_LCMS=false
|
|
LCMS_CFLAGS=""
|
|
LCMS_LIBS=""
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
|
|
$as_echo "bundled" >&6; }
|
|
elif test "x${with_lcms}" = "xsystem"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
|
|
$as_echo "system" >&6; }
|
|
|
|
pkg_failed=no
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LCMS" >&5
|
|
$as_echo_n "checking for LCMS... " >&6; }
|
|
|
|
if test -n "$LCMS_CFLAGS"; then
|
|
pkg_cv_LCMS_CFLAGS="$LCMS_CFLAGS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"lcms2\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "lcms2") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_LCMS_CFLAGS=`$PKG_CONFIG --cflags "lcms2" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
if test -n "$LCMS_LIBS"; then
|
|
pkg_cv_LCMS_LIBS="$LCMS_LIBS"
|
|
elif test -n "$PKG_CONFIG"; then
|
|
if test -n "$PKG_CONFIG" && \
|
|
{ { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"lcms2\""; } >&5
|
|
($PKG_CONFIG --exists --print-errors "lcms2") 2>&5
|
|
ac_status=$?
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
|
|
test $ac_status = 0; }; then
|
|
pkg_cv_LCMS_LIBS=`$PKG_CONFIG --libs "lcms2" 2>/dev/null`
|
|
else
|
|
pkg_failed=yes
|
|
fi
|
|
else
|
|
pkg_failed=untried
|
|
fi
|
|
|
|
|
|
|
|
if test $pkg_failed = yes; then
|
|
|
|
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
|
|
_pkg_short_errors_supported=yes
|
|
else
|
|
_pkg_short_errors_supported=no
|
|
fi
|
|
if test $_pkg_short_errors_supported = yes; then
|
|
LCMS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "lcms2" 2>&1`
|
|
else
|
|
LCMS_PKG_ERRORS=`$PKG_CONFIG --print-errors "lcms2" 2>&1`
|
|
fi
|
|
# Put the nasty error message in config.log where it belongs
|
|
echo "$LCMS_PKG_ERRORS" >&5
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
LCMS_FOUND=no
|
|
elif test $pkg_failed = untried; then
|
|
LCMS_FOUND=no
|
|
else
|
|
LCMS_CFLAGS=$pkg_cv_LCMS_CFLAGS
|
|
LCMS_LIBS=$pkg_cv_LCMS_LIBS
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
LCMS_FOUND=yes
|
|
fi
|
|
if test "x${LCMS_FOUND}" = "xyes"; then
|
|
# PKG_CHECK_MODULES will set LCMS_CFLAGS and LCMS_LIBS
|
|
USE_EXTERNAL_LCMS=true
|
|
else
|
|
as_fn_error $? "--with-lcms=system specified, but no lcms found!" "$LINENO" 5
|
|
fi
|
|
else
|
|
as_fn_error $? "Invalid value for --with-lcms: ${with_lcms}, use 'system' or 'bundled'" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Setup libm (the maths library)
|
|
if test "x$OPENJDK_TARGET_OS" != "xwindows"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5
|
|
$as_echo_n "checking for cos in -lm... " >&6; }
|
|
if ${ac_cv_lib_m_cos+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-lm $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char cos ();
|
|
int
|
|
main ()
|
|
{
|
|
return cos ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_m_cos=yes
|
|
else
|
|
ac_cv_lib_m_cos=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5
|
|
$as_echo "$ac_cv_lib_m_cos" >&6; }
|
|
if test "x$ac_cv_lib_m_cos" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_LIBM 1
|
|
_ACEOF
|
|
|
|
LIBS="-lm $LIBS"
|
|
|
|
else
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5
|
|
$as_echo "$as_me: Maths library was not found" >&6;}
|
|
|
|
fi
|
|
|
|
LIBM="-lm"
|
|
else
|
|
LIBM=""
|
|
fi
|
|
|
|
|
|
# Setup libdl (for dynamic library loading)
|
|
save_LIBS="$LIBS"
|
|
LIBS=""
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
|
|
$as_echo_n "checking for dlopen in -ldl... " >&6; }
|
|
if ${ac_cv_lib_dl_dlopen+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
ac_check_lib_save_LIBS=$LIBS
|
|
LIBS="-ldl $LIBS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
/* Override any GCC internal prototype to avoid an error.
|
|
Use char because int might match the return type of a GCC
|
|
builtin and then its argument prototype would still apply. */
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
char dlopen ();
|
|
int
|
|
main ()
|
|
{
|
|
return dlopen ();
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_link "$LINENO"; then :
|
|
ac_cv_lib_dl_dlopen=yes
|
|
else
|
|
ac_cv_lib_dl_dlopen=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext \
|
|
conftest$ac_exeext conftest.$ac_ext
|
|
LIBS=$ac_check_lib_save_LIBS
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
|
|
$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
|
|
if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
|
|
cat >>confdefs.h <<_ACEOF
|
|
#define HAVE_LIBDL 1
|
|
_ACEOF
|
|
|
|
LIBS="-ldl $LIBS"
|
|
|
|
fi
|
|
|
|
LIBDL="$LIBS"
|
|
|
|
LIBS="$save_LIBS"
|
|
|
|
# Deprecated libraries, keep the flags for backwards compatibility
|
|
if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
|
|
|
|
|
|
# Check whether --with-dxsdk was given.
|
|
if test "${with_dxsdk+set}" = set; then :
|
|
withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-dxsdk-lib was given.
|
|
if test "${with_dxsdk_lib+set}" = set; then :
|
|
withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --with-dxsdk-include was given.
|
|
if test "${with_dxsdk_include+set}" = set; then :
|
|
withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
# Control if libzip can use mmap. Available for purposes of overriding.
|
|
LIBZIP_CAN_USE_MMAP=true
|
|
|
|
|
|
|
|
if test "$OPENJDK_TARGET_OS" = "solaris" && test "x$BUILD_GTEST" = "xtrue"; then
|
|
# Find the root of the Solaris Studio installation from the compiler path
|
|
SOLARIS_STUDIO_DIR="$(dirname $CC)/.."
|
|
STLPORT_LIB="$SOLARIS_STUDIO_DIR/lib/stlport4$OPENJDK_TARGET_CPU_ISADIR/libstlport.so.1"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libstlport.so.1" >&5
|
|
$as_echo_n "checking for libstlport.so.1... " >&6; }
|
|
if ! test -f "$STLPORT_LIB" && test "x$OPENJDK_TARGET_CPU_ISADIR" = "x/sparcv9"; then
|
|
# SS12u3 has libstlport under 'stlport4/v9' instead of 'stlport4/sparcv9'
|
|
STLPORT_LIB="$SOLARIS_STUDIO_DIR/lib/stlport4/v9/libstlport.so.1"
|
|
fi
|
|
if test -f "$STLPORT_LIB"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, $STLPORT_LIB" >&5
|
|
$as_echo "yes, $STLPORT_LIB" >&6; }
|
|
|
|
# Only process if variable expands to non-empty
|
|
|
|
if test "x$STLPORT_LIB" != x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
|
|
# Input might be given as Windows format, start by converting to
|
|
# unix format.
|
|
path="$STLPORT_LIB"
|
|
new_path=`$CYGPATH -u "$path"`
|
|
|
|
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
|
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
|
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
|
# "foo.exe" is OK but "foo" is an error.
|
|
#
|
|
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
|
# It is also a way to make sure we got the proper file name for the real test later on.
|
|
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
|
if test "x$test_shortpath" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Cannot locate the the path of STLPORT_LIB" "$LINENO" 5
|
|
fi
|
|
|
|
# Call helper function which possibly converts this using DOS-style short mode.
|
|
# If so, the updated path is stored in $new_path.
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
|
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
|
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
|
# Going to short mode and back again did indeed matter. Since short mode is
|
|
# case insensitive, let's make it lowercase to improve readability.
|
|
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
# Now convert it back to Unix-style (cygpath)
|
|
input_path=`$CYGPATH -u "$shortmode_path"`
|
|
new_path="$input_path"
|
|
fi
|
|
fi
|
|
|
|
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
|
if test "x$test_cygdrive_prefix" = x; then
|
|
# As a simple fix, exclude /usr/bin since it's not a real path.
|
|
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
|
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
|
# a path prefixed by /cygdrive for fixpath to work.
|
|
new_path="$CYGWIN_ROOT_PATH$input_path"
|
|
fi
|
|
fi
|
|
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
STLPORT_LIB="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STLPORT_LIB to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting STLPORT_LIB to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
|
|
path="$STLPORT_LIB"
|
|
has_colon=`$ECHO $path | $GREP ^.:`
|
|
new_path="$path"
|
|
if test "x$has_colon" = x; then
|
|
# Not in mixed or Windows style, start by that.
|
|
new_path=`cmd //c echo $path`
|
|
fi
|
|
|
|
|
|
input_path="$new_path"
|
|
# Check if we need to convert this using DOS-style short mode. If the path
|
|
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
|
# take no chances and rewrite it.
|
|
# Note: m4 eats our [], so we need to use [ and ] instead.
|
|
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
|
if test "x$has_forbidden_chars" != x; then
|
|
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
|
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
|
fi
|
|
|
|
|
|
windows_path="$new_path"
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
unix_path=`$CYGPATH -u "$windows_path"`
|
|
new_path="$unix_path"
|
|
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
|
new_path="$unix_path"
|
|
fi
|
|
|
|
if test "x$path" != "x$new_path"; then
|
|
STLPORT_LIB="$new_path"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STLPORT_LIB to \"$new_path\"" >&5
|
|
$as_echo "$as_me: Rewriting STLPORT_LIB to \"$new_path\"" >&6;}
|
|
fi
|
|
|
|
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
|
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
|
|
|
else
|
|
# We're on a unix platform. Hooray! :)
|
|
path="$STLPORT_LIB"
|
|
has_space=`$ECHO "$path" | $GREP " "`
|
|
if test "x$has_space" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&5
|
|
$as_echo "$as_me: The path of STLPORT_LIB, which resolves as \"$path\", is invalid." >&6;}
|
|
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
|
fi
|
|
|
|
# Use eval to expand a potential ~
|
|
eval path="$path"
|
|
if test ! -f "$path" && test ! -d "$path"; then
|
|
as_fn_error $? "The path of STLPORT_LIB, which resolves as \"$path\", is not found." "$LINENO" 5
|
|
fi
|
|
|
|
if test -d "$path"; then
|
|
STLPORT_LIB="`cd "$path"; $THEPWDCMD -L`"
|
|
else
|
|
dir="`$DIRNAME "$path"`"
|
|
base="`$BASENAME "$path"`"
|
|
STLPORT_LIB="`cd "$dir"; $THEPWDCMD -L`/$base"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, not found at $STLPORT_LIB" >&5
|
|
$as_echo "no, not found at $STLPORT_LIB" >&6; }
|
|
as_fn_error $? "Failed to find libstlport.so.1, cannot build Hotspot gtests" "$LINENO" 5
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Hotspot setup depends on lib checks.
|
|
|
|
|
|
# The user can in some cases supply additional jvm features. For the custom
|
|
# variant, this defines the entire variant.
|
|
|
|
# Check whether --with-jvm-features was given.
|
|
if test "${with_jvm_features+set}" = set; then :
|
|
withval=$with_jvm_features;
|
|
fi
|
|
|
|
if test "x$with_jvm_features" != x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking additional JVM features" >&5
|
|
$as_echo_n "checking additional JVM features... " >&6; }
|
|
JVM_FEATURES=`$ECHO $with_jvm_features | $SED -e 's/,/ /g'`
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_FEATURES" >&5
|
|
$as_echo "$JVM_FEATURES" >&6; }
|
|
fi
|
|
|
|
# Override hotspot cpu definitions for ARM platforms
|
|
if test "x$OPENJDK_TARGET_CPU" = xarm; then
|
|
HOTSPOT_TARGET_CPU=arm_32
|
|
HOTSPOT_TARGET_CPU_DEFINE="ARM32"
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -fsigned-char"
|
|
JVM_CFLAGS="$JVM_CFLAGS -DARM -fsigned-char"
|
|
elif test "x$OPENJDK_TARGET_CPU" = xaarch64 && test "x$HOTSPOT_TARGET_CPU_PORT" = xarm64; then
|
|
HOTSPOT_TARGET_CPU=arm_64
|
|
HOTSPOT_TARGET_CPU_ARCH=arm
|
|
JVM_LDFLAGS="$JVM_LDFLAGS -fsigned-char"
|
|
JVM_CFLAGS="$JVM_CFLAGS -DARM -fsigned-char"
|
|
fi
|
|
|
|
# Verify that dependencies are met for explicitly set features.
|
|
if [[ " $JVM_FEATURES " =~ " jvmti " ]] && ! [[ " $JVM_FEATURES " =~ " services " ]] ; then
|
|
as_fn_error $? "Specified JVM feature 'jvmti' requires feature 'services'" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ " $JVM_FEATURES " =~ " management " ]] && ! [[ " $JVM_FEATURES " =~ " nmt " ]] ; then
|
|
as_fn_error $? "Specified JVM feature 'management' requires feature 'nmt'" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ " $JVM_FEATURES " =~ " jvmci " ]] && ! ( [[ " $JVM_FEATURES " =~ " compiler1 " ]] || [[ " $JVM_FEATURES " =~ " compiler2 " ]] ); then
|
|
as_fn_error $? "Specified JVM feature 'jvmci' requires feature 'compiler2' or 'compiler1'" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ " $JVM_FEATURES " =~ " compiler2 " ]] && ! [[ " $JVM_FEATURES " =~ " all-gcs " ]] ; then
|
|
as_fn_error $? "Specified JVM feature 'compiler2' requires feature 'all-gcs'" "$LINENO" 5
|
|
fi
|
|
|
|
if [[ " $JVM_FEATURES " =~ " vm-structs " ]] && ! [[ " $JVM_FEATURES " =~ " all-gcs " ]] ; then
|
|
as_fn_error $? "Specified JVM feature 'vm-structs' requires feature 'all-gcs'" "$LINENO" 5
|
|
fi
|
|
|
|
# Turn on additional features based on other parts of configure
|
|
if test "x$INCLUDE_DTRACE" = "xtrue"; then
|
|
JVM_FEATURES="$JVM_FEATURES dtrace"
|
|
else
|
|
if [[ " $JVM_FEATURES " =~ " dtrace " ]] ; then
|
|
as_fn_error $? "To enable dtrace, you must use --enable-dtrace" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
if test "x$STATIC_BUILD" = "xtrue"; then
|
|
JVM_FEATURES="$JVM_FEATURES static-build"
|
|
else
|
|
if [[ " $JVM_FEATURES " =~ " static-build " ]] ; then
|
|
as_fn_error $? "To enable static-build, you must use --enable-static-build" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
if [[ " $JVM_FEATURES " =~ " zero " ]] ; then
|
|
as_fn_error $? "To enable zero/zeroshark, you must use --with-jvm-variants=zero/zeroshark" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
if ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
|
|
if [[ " $JVM_FEATURES " =~ " shark " ]] ; then
|
|
as_fn_error $? "To enable shark, you must use --with-jvm-variants=zeroshark" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
# Only enable jvmci on x86_64, sparcv9 and aarch64.
|
|
if test "x$OPENJDK_TARGET_CPU" = "xx86_64" || \
|
|
test "x$OPENJDK_TARGET_CPU" = "xsparcv9" || \
|
|
test "x$OPENJDK_TARGET_CPU" = "xaarch64" ; then
|
|
JVM_FEATURES_jvmci="jvmci"
|
|
else
|
|
JVM_FEATURES_jvmci=""
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if jdk.internal.vm.compiler should be built" >&5
|
|
$as_echo_n "checking if jdk.internal.vm.compiler should be built... " >&6; }
|
|
if [[ " $JVM_FEATURES " =~ " graal " ]] ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
if test "x$JVM_FEATURES_jvmci" != "xjvmci" ; then
|
|
as_fn_error $? "Specified JVM feature 'graal' requires feature 'jvmci'" "$LINENO" 5
|
|
fi
|
|
INCLUDE_GRAAL="true"
|
|
else
|
|
# By default enable graal build on linux-x64 or where AOT is available.
|
|
# graal build requires jvmci.
|
|
if test "x$JVM_FEATURES_jvmci" = "xjvmci" && \
|
|
(test "x$OPENJDK_TARGET_CPU" = "xx86_64" && \
|
|
test "x$OPENJDK_TARGET_OS" = "xlinux" || \
|
|
test "x$ENABLE_AOT" = "xtrue") ; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
JVM_FEATURES_graal="graal"
|
|
INCLUDE_GRAAL="true"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
JVM_FEATURES_graal=""
|
|
INCLUDE_GRAAL="false"
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if aot should be enabled" >&5
|
|
$as_echo_n "checking if aot should be enabled... " >&6; }
|
|
if test "x$ENABLE_AOT" = "xtrue"; then
|
|
if test "x$enable_aot" = "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
JVM_FEATURES_aot="aot"
|
|
else
|
|
if test "x$enable_aot" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
JVM_FEATURES_aot=""
|
|
fi
|
|
|
|
if test "x$OPENJDK_TARGET_CPU" = xarm ; then
|
|
# Default to use link time optimizations on minimal on arm
|
|
JVM_FEATURES_link_time_opt="link-time-opt"
|
|
else
|
|
JVM_FEATURES_link_time_opt=""
|
|
fi
|
|
|
|
# All variants but minimal (and custom) get these features
|
|
NON_MINIMAL_FEATURES="$NON_MINIMAL_FEATURES jvmti vm-structs jni-check services management all-gcs nmt"
|
|
if test "x$ENABLE_CDS" = "xtrue"; then
|
|
NON_MINIMAL_FEATURES="$NON_MINIMAL_FEATURES cds"
|
|
fi
|
|
|
|
# Enable features depending on variant.
|
|
JVM_FEATURES_server="compiler1 compiler2 $NON_MINIMAL_FEATURES $JVM_FEATURES $JVM_FEATURES_jvmci $JVM_FEATURES_aot $JVM_FEATURES_graal"
|
|
JVM_FEATURES_client="compiler1 $NON_MINIMAL_FEATURES $JVM_FEATURES $JVM_FEATURES_jvmci"
|
|
JVM_FEATURES_core="$NON_MINIMAL_FEATURES $JVM_FEATURES"
|
|
JVM_FEATURES_minimal="compiler1 minimal $JVM_FEATURES $JVM_FEATURES_link_time_opt"
|
|
JVM_FEATURES_zero="zero $NON_MINIMAL_FEATURES $JVM_FEATURES"
|
|
JVM_FEATURES_zeroshark="zero shark $NON_MINIMAL_FEATURES $JVM_FEATURES"
|
|
JVM_FEATURES_custom="$JVM_FEATURES"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Used for verification of Makefiles by check-jvm-feature
|
|
|
|
|
|
# We don't support --with-jvm-interpreter anymore, use zero instead.
|
|
|
|
|
|
# Check whether --with-jvm-interpreter was given.
|
|
if test "${with_jvm_interpreter+set}" = set; then :
|
|
withval=$with_jvm_interpreter; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-jvm-interpreter is deprecated and will be ignored." >&5
|
|
$as_echo "$as_me: WARNING: Option --with-jvm-interpreter is deprecated and will be ignored." >&2;}
|
|
fi
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# We need to do some final tweaking, when everything else is done.
|
|
#
|
|
###############################################################################
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
|
|
$as_echo_n "checking if elliptic curve crypto implementation is present... " >&6; }
|
|
|
|
if test -d "${SRC_ROOT}/jdk/src/jdk.crypto.ec/share/native/libsunec/impl"; then
|
|
ENABLE_INTREE_EC=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
else
|
|
ENABLE_INTREE_EC=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --enable-jtreg-failure-handler was given.
|
|
if test "${enable_jtreg_failure_handler+set}" = set; then :
|
|
enableval=$enable_jtreg_failure_handler;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if jtreg failure handler should be built" >&5
|
|
$as_echo_n "checking if jtreg failure handler should be built... " >&6; }
|
|
|
|
if test "x$enable_jtreg_failure_handler" = "xyes"; then
|
|
if test "x$JT_HOME" = "x"; then
|
|
as_fn_error $? "Cannot enable jtreg failure handler without jtreg." "$LINENO" 5
|
|
else
|
|
BUILD_FAILURE_HANDLER=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
fi
|
|
elif test "x$enable_jtreg_failure_handler" = "xno"; then
|
|
BUILD_FAILURE_HANDLER=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
elif test "x$enable_jtreg_failure_handler" = "xauto" \
|
|
|| test "x$enable_jtreg_failure_handler" = "x"; then
|
|
if test "x$JT_HOME" = "x"; then
|
|
BUILD_FAILURE_HANDLER=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, missing jtreg" >&5
|
|
$as_echo "no, missing jtreg" >&6; }
|
|
else
|
|
BUILD_FAILURE_HANDLER=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, jtreg present" >&5
|
|
$as_echo "yes, jtreg present" >&6; }
|
|
fi
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-jtreg-failure-handler: $enable_jtreg_failure_handler" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Check whether --enable-generate-classlist was given.
|
|
if test "${enable_generate_classlist+set}" = set; then :
|
|
enableval=$enable_generate_classlist;
|
|
fi
|
|
|
|
|
|
# Check if it's likely that it's possible to generate the classlist. Depending
|
|
# on exact jvm configuration it could be possible anyway.
|
|
if test "x$ENABLE_CDS" = "xtrue" && ( [[ " $JVM_VARIANTS " =~ " server " ]] || [[ " $JVM_VARIANTS " =~ " client " ]] ); then
|
|
ENABLE_GENERATE_CLASSLIST_POSSIBLE="true"
|
|
else
|
|
ENABLE_GENERATE_CLASSLIST_POSSIBLE="false"
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the CDS classlist generation should be enabled" >&5
|
|
$as_echo_n "checking if the CDS classlist generation should be enabled... " >&6; }
|
|
if test "x$enable_generate_classlist" = "xyes"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, forced" >&5
|
|
$as_echo "yes, forced" >&6; }
|
|
ENABLE_GENERATE_CLASSLIST="true"
|
|
if test "x$ENABLE_GENERATE_CLASSLIST_POSSIBLE" = "xfalse"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Generation of classlist might not be possible with JVM Variants $JVM_VARIANTS and enable-cds=$ENABLE_CDS" >&5
|
|
$as_echo "$as_me: WARNING: Generation of classlist might not be possible with JVM Variants $JVM_VARIANTS and enable-cds=$ENABLE_CDS" >&2;}
|
|
fi
|
|
elif test "x$enable_generate_classlist" = "xno"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
ENABLE_GENERATE_CLASSLIST="false"
|
|
elif test "x$enable_generate_classlist" = "x"; then
|
|
if test "x$ENABLE_GENERATE_CLASSLIST_POSSIBLE" = "xtrue"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
ENABLE_GENERATE_CLASSLIST="true"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
ENABLE_GENERATE_CLASSLIST="false"
|
|
fi
|
|
else
|
|
as_fn_error $? "Invalid value for --enable-generate-classlist: $enable_generate_classlist" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Configure parts of the build that only affect the build performance,
|
|
# not the result.
|
|
#
|
|
###############################################################################
|
|
|
|
|
|
# How many cores do we have on this build system?
|
|
|
|
# Check whether --with-num-cores was given.
|
|
if test "${with_num_cores+set}" = set; then :
|
|
withval=$with_num_cores;
|
|
fi
|
|
|
|
if test "x$with_num_cores" = x; then
|
|
# The number of cores were not specified, try to probe them.
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5
|
|
$as_echo_n "checking for number of cores... " >&6; }
|
|
NUM_CORES=1
|
|
FOUND_CORES=no
|
|
|
|
if test -f /proc/cpuinfo; then
|
|
# Looks like a Linux (or cygwin) system
|
|
NUM_CORES=`cat /proc/cpuinfo | grep -c processor`
|
|
FOUND_CORES=yes
|
|
elif test -x /usr/sbin/psrinfo; then
|
|
# Looks like a Solaris system
|
|
NUM_CORES=`LC_MESSAGES=C /usr/sbin/psrinfo -v | grep -c on-line`
|
|
FOUND_CORES=yes
|
|
elif test -x /usr/sbin/sysctl; then
|
|
# Looks like a MacOSX system
|
|
NUM_CORES=`/usr/sbin/sysctl -n hw.ncpu`
|
|
FOUND_CORES=yes
|
|
elif test "x$OPENJDK_BUILD_OS" = xaix ; then
|
|
NUM_CORES=`/usr/sbin/prtconf | grep "^Number Of Processors" | awk '{ print $4 }'`
|
|
FOUND_CORES=yes
|
|
elif test -n "$NUMBER_OF_PROCESSORS"; then
|
|
# On windows, look in the env
|
|
NUM_CORES=$NUMBER_OF_PROCESSORS
|
|
FOUND_CORES=yes
|
|
fi
|
|
|
|
if test "x$FOUND_CORES" = xyes; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5
|
|
$as_echo "$NUM_CORES" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1" >&5
|
|
$as_echo "could not detect number of cores, defaulting to 1" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This will disable all parallelism from build!" >&5
|
|
$as_echo "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
|
|
fi
|
|
|
|
else
|
|
NUM_CORES=$with_num_cores
|
|
fi
|
|
|
|
|
|
|
|
# How much memory do we have on this build system?
|
|
|
|
# Check whether --with-memory-size was given.
|
|
if test "${with_memory_size+set}" = set; then :
|
|
withval=$with_memory_size;
|
|
fi
|
|
|
|
if test "x$with_memory_size" = x; then
|
|
# The memory size was not specified, try to probe it.
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5
|
|
$as_echo_n "checking for memory size... " >&6; }
|
|
# Default to 1024 MB
|
|
MEMORY_SIZE=1024
|
|
FOUND_MEM=no
|
|
|
|
if test -f /proc/meminfo; then
|
|
# Looks like a Linux (or cygwin) system
|
|
MEMORY_SIZE=`cat /proc/meminfo | grep MemTotal | awk '{print $2}'`
|
|
MEMORY_SIZE=`expr $MEMORY_SIZE / 1024`
|
|
FOUND_MEM=yes
|
|
elif test -x /usr/sbin/prtconf; then
|
|
# Looks like a Solaris or AIX system
|
|
MEMORY_SIZE=`/usr/sbin/prtconf 2> /dev/null | grep "^Memory [Ss]ize" | awk '{ print $3 }'`
|
|
FOUND_MEM=yes
|
|
elif test -x /usr/sbin/sysctl; then
|
|
# Looks like a MacOSX system
|
|
MEMORY_SIZE=`/usr/sbin/sysctl -n hw.memsize`
|
|
MEMORY_SIZE=`expr $MEMORY_SIZE / 1024 / 1024`
|
|
FOUND_MEM=yes
|
|
elif test "x$OPENJDK_BUILD_OS" = xwindows; then
|
|
# Windows, but without cygwin
|
|
MEMORY_SIZE=`wmic computersystem get totalphysicalmemory -value | grep = | cut -d "=" -f 2-`
|
|
MEMORY_SIZE=`expr $MEMORY_SIZE / 1024 / 1024`
|
|
FOUND_MEM=yes
|
|
fi
|
|
|
|
if test "x$FOUND_MEM" = xyes; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5
|
|
$as_echo "$MEMORY_SIZE MB" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect memory size, defaulting to $MEMORY_SIZE MB" >&5
|
|
$as_echo "could not detect memory size, defaulting to $MEMORY_SIZE MB" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This might seriously impact build performance!" >&5
|
|
$as_echo "$as_me: WARNING: This might seriously impact build performance!" >&2;}
|
|
fi
|
|
|
|
else
|
|
MEMORY_SIZE=$with_memory_size
|
|
fi
|
|
|
|
|
|
|
|
# Provide a decent default number of parallel jobs for make depending on
|
|
# number of cores, amount of memory and machine architecture.
|
|
|
|
# Check whether --with-jobs was given.
|
|
if test "${with_jobs+set}" = set; then :
|
|
withval=$with_jobs;
|
|
fi
|
|
|
|
if test "x$with_jobs" = x; then
|
|
# Number of jobs was not specified, calculate.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
|
|
$as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6; }
|
|
# Approximate memory in GB.
|
|
memory_gb=`expr $MEMORY_SIZE / 1024`
|
|
# Pick the lowest of memory in gb and number of cores.
|
|
if test "$memory_gb" -lt "$NUM_CORES"; then
|
|
JOBS="$memory_gb"
|
|
else
|
|
JOBS="$NUM_CORES"
|
|
fi
|
|
if test "$JOBS" -eq "0"; then
|
|
JOBS=1
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JOBS" >&5
|
|
$as_echo "$JOBS" >&6; }
|
|
else
|
|
JOBS=$with_jobs
|
|
fi
|
|
|
|
|
|
|
|
# The number of test jobs will be chosen automatically if TEST_JOBS is 0
|
|
|
|
# Check whether --with-test-jobs was given.
|
|
if test "${with_test_jobs+set}" = set; then :
|
|
withval=$with_test_jobs;
|
|
fi
|
|
|
|
if test "x$with_test_jobs" = x; then
|
|
TEST_JOBS=0
|
|
else
|
|
TEST_JOBS=$with_test_jobs
|
|
fi
|
|
|
|
|
|
|
|
# Setup arguments for the boot jdk (after cores and memory have been setup)
|
|
|
|
##############################################################################
|
|
#
|
|
# Specify jvm options for anything that is run with the Boot JDK.
|
|
# Not all JVM:s accept the same arguments on the command line.
|
|
#
|
|
|
|
# Check whether --with-boot-jdk-jvmargs was given.
|
|
if test "${with_boot_jdk_jvmargs+set}" = set; then :
|
|
withval=$with_boot_jdk_jvmargs;
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
|
|
$as_echo_n "checking flags for boot jdk java command ... " >&6; }
|
|
|
|
# Disable special log output when a debug build is used as Boot JDK...
|
|
|
|
$ECHO "Check if jvm arg is ok: -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" >&5
|
|
$ECHO "Command: $JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version" >&5
|
|
OUTPUT=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
# Force en-US environment
|
|
|
|
$ECHO "Check if jvm arg is ok: -Duser.language=en -Duser.country=US" >&5
|
|
$ECHO "Command: $JAVA -Duser.language=en -Duser.country=US -version" >&5
|
|
OUTPUT=`$JAVA -Duser.language=en -Duser.country=US -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs="$boot_jdk_jvmargs -Duser.language=en -Duser.country=US"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
# Apply user provided options.
|
|
|
|
$ECHO "Check if jvm arg is ok: $with_boot_jdk_jvmargs" >&5
|
|
$ECHO "Command: $JAVA $with_boot_jdk_jvmargs -version" >&5
|
|
OUTPUT=`$JAVA $with_boot_jdk_jvmargs -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs="$boot_jdk_jvmargs $with_boot_jdk_jvmargs"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
|
|
$as_echo "$boot_jdk_jvmargs" >&6; }
|
|
|
|
# For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
|
|
JAVA_FLAGS=$boot_jdk_jvmargs
|
|
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
|
|
$as_echo_n "checking flags for boot jdk java command for big workloads... " >&6; }
|
|
|
|
# Starting amount of heap memory.
|
|
|
|
$ECHO "Check if jvm arg is ok: -Xms64M" >&5
|
|
$ECHO "Command: $JAVA -Xms64M -version" >&5
|
|
OUTPUT=`$JAVA -Xms64M -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xms64M"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
BOOTCYCLE_JVM_ARGS_BIG=-Xms64M
|
|
|
|
# Maximum amount of heap memory and stack size.
|
|
JVM_HEAP_LIMIT_32="1024"
|
|
# Running a 64 bit JVM allows for and requires a bigger heap
|
|
JVM_HEAP_LIMIT_64="1600"
|
|
STACK_SIZE_32=768
|
|
STACK_SIZE_64=1536
|
|
JVM_HEAP_LIMIT_GLOBAL=`expr $MEMORY_SIZE / 2`
|
|
if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_32"; then
|
|
JVM_HEAP_LIMIT_32=$JVM_HEAP_LIMIT_GLOBAL
|
|
fi
|
|
if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_64"; then
|
|
JVM_HEAP_LIMIT_64=$JVM_HEAP_LIMIT_GLOBAL
|
|
fi
|
|
if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "512"; then
|
|
JVM_HEAP_LIMIT_32=512
|
|
JVM_HEAP_LIMIT_64=512
|
|
fi
|
|
|
|
if test "x$BOOT_JDK_BITS" = "x32"; then
|
|
STACK_SIZE=$STACK_SIZE_32
|
|
JVM_MAX_HEAP=$JVM_HEAP_LIMIT_32
|
|
else
|
|
STACK_SIZE=$STACK_SIZE_64
|
|
JVM_MAX_HEAP=$JVM_HEAP_LIMIT_64
|
|
fi
|
|
|
|
$ECHO "Check if jvm arg is ok: -Xmx${JVM_MAX_HEAP}M" >&5
|
|
$ECHO "Command: $JAVA -Xmx${JVM_MAX_HEAP}M -version" >&5
|
|
OUTPUT=`$JAVA -Xmx${JVM_MAX_HEAP}M -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xmx${JVM_MAX_HEAP}M"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
$ECHO "Check if jvm arg is ok: -XX:ThreadStackSize=$STACK_SIZE" >&5
|
|
$ECHO "Command: $JAVA -XX:ThreadStackSize=$STACK_SIZE -version" >&5
|
|
OUTPUT=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -XX:ThreadStackSize=$STACK_SIZE"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
|
|
$as_echo "$boot_jdk_jvmargs_big" >&6; }
|
|
|
|
JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
|
|
|
|
|
|
if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
|
|
BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_32
|
|
BOOTCYCLE_STACK_SIZE=$STACK_SIZE_32
|
|
else
|
|
BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_64
|
|
BOOTCYCLE_STACK_SIZE=$STACK_SIZE_64
|
|
fi
|
|
BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -Xmx${BOOTCYCLE_MAX_HEAP}M"
|
|
BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -XX:ThreadStackSize=$BOOTCYCLE_STACK_SIZE"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for bootcycle boot jdk java command for big workloads" >&5
|
|
$as_echo_n "checking flags for bootcycle boot jdk java command for big workloads... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOTCYCLE_JVM_ARGS_BIG" >&5
|
|
$as_echo "$BOOTCYCLE_JVM_ARGS_BIG" >&6; }
|
|
|
|
|
|
# By default, the main javac compilations use big
|
|
JAVA_FLAGS_JAVAC="$JAVA_FLAGS_BIG"
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
|
|
$as_echo_n "checking flags for boot jdk java command for small workloads... " >&6; }
|
|
|
|
# Use serial gc for small short lived tools if possible
|
|
|
|
$ECHO "Check if jvm arg is ok: -XX:+UseSerialGC" >&5
|
|
$ECHO "Command: $JAVA -XX:+UseSerialGC -version" >&5
|
|
OUTPUT=`$JAVA -XX:+UseSerialGC -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -XX:+UseSerialGC"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
$ECHO "Check if jvm arg is ok: -Xms32M" >&5
|
|
$ECHO "Command: $JAVA -Xms32M -version" >&5
|
|
OUTPUT=`$JAVA -Xms32M -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xms32M"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
$ECHO "Check if jvm arg is ok: -Xmx512M" >&5
|
|
$ECHO "Command: $JAVA -Xmx512M -version" >&5
|
|
OUTPUT=`$JAVA -Xmx512M -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xmx512M"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
$ECHO "Check if jvm arg is ok: -XX:TieredStopAtLevel=1" >&5
|
|
$ECHO "Command: $JAVA -XX:TieredStopAtLevel=1 -version" >&5
|
|
OUTPUT=`$JAVA -XX:TieredStopAtLevel=1 -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -XX:TieredStopAtLevel=1"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
|
|
$as_echo "$boot_jdk_jvmargs_small" >&6; }
|
|
|
|
JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
|
|
|
|
|
|
JAVA_TOOL_FLAGS_SMALL=""
|
|
for f in $JAVA_FLAGS_SMALL; do
|
|
JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
|
|
done
|
|
|
|
|
|
|
|
# Setup smart javac (after cores and memory have been setup)
|
|
|
|
|
|
# Check whether --with-sjavac-server-java was given.
|
|
if test "${with_sjavac_server_java+set}" = set; then :
|
|
withval=$with_sjavac_server_java;
|
|
fi
|
|
|
|
|
|
if test "x$with_sjavac_server_java" != x; then
|
|
SJAVAC_SERVER_JAVA="$with_sjavac_server_java"
|
|
FOUND_VERSION=`$SJAVAC_SERVER_JAVA -version 2>&1 | grep " version \""`
|
|
if test "x$FOUND_VERSION" = x; then
|
|
as_fn_error $? "Could not execute server java: $SJAVAC_SERVER_JAVA" "$LINENO" 5
|
|
fi
|
|
else
|
|
SJAVAC_SERVER_JAVA="$JAVA"
|
|
fi
|
|
|
|
|
|
if test "$MEMORY_SIZE" -gt "3000"; then
|
|
if "$JAVA" -version 2>&1 | $GREP -q "64-Bit"; then
|
|
JVM_64BIT=true
|
|
fi
|
|
fi
|
|
|
|
MX_VALUE=`expr $MEMORY_SIZE / 2`
|
|
if test "$JVM_64BIT" = true; then
|
|
# Set ms lower than mx since more than one instance of the server might
|
|
# get launched at the same time before they figure out which instance won.
|
|
MS_VALUE=512
|
|
if test "$MX_VALUE" -gt "2048"; then
|
|
MX_VALUE=2048
|
|
fi
|
|
else
|
|
MS_VALUE=256
|
|
if test "$MX_VALUE" -gt "1500"; then
|
|
MX_VALUE=1500
|
|
fi
|
|
fi
|
|
if test "$MX_VALUE" -lt "512"; then
|
|
MX_VALUE=512
|
|
fi
|
|
|
|
$ECHO "Check if jvm arg is ok: -Xms${MS_VALUE}M -Xmx${MX_VALUE}M" >&5
|
|
$ECHO "Command: $SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M -version" >&5
|
|
OUTPUT=`$SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M -version 2>&1`
|
|
FOUND_WARN=`$ECHO "$OUTPUT" | $GREP -i warn`
|
|
FOUND_VERSION=`$ECHO $OUTPUT | $GREP " version \""`
|
|
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
|
|
SJAVAC_SERVER_JAVA_FLAGS="$SJAVAC_SERVER_JAVA_FLAGS -Xms${MS_VALUE}M -Xmx${MX_VALUE}M"
|
|
JVM_ARG_OK=true
|
|
else
|
|
$ECHO "Arg failed:" >&5
|
|
$ECHO "$OUTPUT" >&5
|
|
JVM_ARG_OK=false
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --enable-sjavac was given.
|
|
if test "${enable_sjavac+set}" = set; then :
|
|
enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
|
|
else
|
|
ENABLE_SJAVAC="no"
|
|
fi
|
|
|
|
if test "x$JVM_ARG_OK" = "xfalse"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling sjavac" >&5
|
|
$as_echo "$as_me: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling sjavac" >&2;}
|
|
ENABLE_SJAVAC="no"
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
|
|
$as_echo_n "checking whether to use sjavac... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
|
|
$as_echo "$ENABLE_SJAVAC" >&6; }
|
|
|
|
|
|
# Check whether --enable-javac-server was given.
|
|
if test "${enable_javac_server+set}" = set; then :
|
|
enableval=$enable_javac_server; ENABLE_JAVAC_SERVER="${enableval}"
|
|
else
|
|
ENABLE_JAVAC_SERVER="yes"
|
|
fi
|
|
|
|
if test "x$JVM_ARG_OK" = "xfalse"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling javac server" >&5
|
|
$as_echo "$as_me: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling javac server" >&2;}
|
|
ENABLE_JAVAC_SERVER="no"
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use javac server" >&5
|
|
$as_echo_n "checking whether to use javac server... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JAVAC_SERVER" >&5
|
|
$as_echo "$ENABLE_JAVAC_SERVER" >&6; }
|
|
|
|
|
|
if test "x$ENABLE_JAVAC_SERVER" = "xyes" || test "x$ENABLE_SJAVAC" = "xyes"; then
|
|
# When using a server javac, the small client instances do not need much
|
|
# resources.
|
|
JAVA_FLAGS_JAVAC="$JAVA_FLAGS_SMALL"
|
|
fi
|
|
|
|
|
|
# Setup use of icecc if requested
|
|
|
|
# Check whether --enable-icecc was given.
|
|
if test "${enable_icecc+set}" = set; then :
|
|
enableval=$enable_icecc;
|
|
fi
|
|
|
|
|
|
if test "x${enable_icecc}" = "xyes"; then
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${ICECC_CMD+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in icecc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_CMD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_CMD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_CMD="$ICECC_CMD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_CMD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_CMD=$ac_cv_path_ICECC_CMD
|
|
if test -n "$ICECC_CMD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CMD" >&5
|
|
$as_echo "$ICECC_CMD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ICECC_CMD" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !ICECC_CMD! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ICECC_CMD!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xICECC_CMD" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ICECC_CMD from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of ICECC_CMD from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in icecc
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_CMD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_CMD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_CMD="$ICECC_CMD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_CMD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_CMD=$ac_cv_path_ICECC_CMD
|
|
if test -n "$ICECC_CMD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CMD" >&5
|
|
$as_echo "$ICECC_CMD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ICECC_CMD" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$ICECC_CMD" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ICECC_CMD= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool ICECC_CMD= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CMD" >&5
|
|
$as_echo_n "checking for ICECC_CMD... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$ICECC_CMD"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ICECC_CMD=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool ICECC_CMD=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_CMD+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_CMD in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_CMD="$ICECC_CMD" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_CMD="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_CMD=$ac_cv_path_ICECC_CMD
|
|
if test -n "$ICECC_CMD"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CMD" >&5
|
|
$as_echo "$ICECC_CMD" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$ICECC_CMD" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ICECC_CMD=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool ICECC_CMD=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CMD" >&5
|
|
$as_echo_n "checking for ICECC_CMD... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool ICECC_CMD=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$ICECC_CMD" = x; then
|
|
as_fn_error $? "Could not find required tool for ICECC_CMD" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
old_path="$PATH"
|
|
|
|
# Look for icecc-create-env in some known places
|
|
PATH="$PATH:/usr/lib/icecc:/usr/lib64/icecc"
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${ICECC_CREATE_ENV+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in icecc-create-env
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_CREATE_ENV+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_CREATE_ENV in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_CREATE_ENV="$ICECC_CREATE_ENV" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_CREATE_ENV="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_CREATE_ENV=$ac_cv_path_ICECC_CREATE_ENV
|
|
if test -n "$ICECC_CREATE_ENV"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CREATE_ENV" >&5
|
|
$as_echo "$ICECC_CREATE_ENV" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ICECC_CREATE_ENV" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !ICECC_CREATE_ENV! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ICECC_CREATE_ENV!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xICECC_CREATE_ENV" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ICECC_CREATE_ENV from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of ICECC_CREATE_ENV from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in icecc-create-env
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_CREATE_ENV+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_CREATE_ENV in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_CREATE_ENV="$ICECC_CREATE_ENV" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_CREATE_ENV="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_CREATE_ENV=$ac_cv_path_ICECC_CREATE_ENV
|
|
if test -n "$ICECC_CREATE_ENV"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CREATE_ENV" >&5
|
|
$as_echo "$ICECC_CREATE_ENV" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ICECC_CREATE_ENV" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$ICECC_CREATE_ENV" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ICECC_CREATE_ENV= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool ICECC_CREATE_ENV= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CREATE_ENV" >&5
|
|
$as_echo_n "checking for ICECC_CREATE_ENV... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$ICECC_CREATE_ENV"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ICECC_CREATE_ENV=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool ICECC_CREATE_ENV=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_CREATE_ENV+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_CREATE_ENV in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_CREATE_ENV="$ICECC_CREATE_ENV" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_CREATE_ENV="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_CREATE_ENV=$ac_cv_path_ICECC_CREATE_ENV
|
|
if test -n "$ICECC_CREATE_ENV"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_CREATE_ENV" >&5
|
|
$as_echo "$ICECC_CREATE_ENV" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$ICECC_CREATE_ENV" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ICECC_CREATE_ENV=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool ICECC_CREATE_ENV=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_CREATE_ENV" >&5
|
|
$as_echo_n "checking for ICECC_CREATE_ENV... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool ICECC_CREATE_ENV=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$ICECC_CREATE_ENV" = x; then
|
|
as_fn_error $? "Could not find required tool for ICECC_CREATE_ENV" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
# Use icecc-create-env to create a minimal compilation environment that can
|
|
# be sent to the other hosts in the icecream cluster.
|
|
icecc_create_env_log="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/icecc_create_env.log"
|
|
${MKDIR} -p ${CONFIGURESUPPORT_OUTPUTDIR}/icecc
|
|
# Older versions of icecc does not have the --gcc parameter
|
|
if ${ICECC_CREATE_ENV} | $GREP -q -e --gcc; then
|
|
icecc_gcc_arg="--gcc"
|
|
fi
|
|
if test "x${TOOLCHAIN_TYPE}" = "xgcc"; then
|
|
|
|
( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
|
|
&& ${ICECC_CREATE_ENV} ${icecc_gcc_arg} ${CC} ${CXX} > \
|
|
${icecc_create_env_log} 2>&1 )
|
|
if test "$?" != "0"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
|
|
$as_echo "$as_me: icecc-create-env output:" >&6;}
|
|
cat \
|
|
${icecc_create_env_log}
|
|
as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
|
|
fi
|
|
|
|
elif test "x$TOOLCHAIN_TYPE" = "xclang"; then
|
|
# For clang, the icecc compilerwrapper is needed. It usually resides next
|
|
# to icecc-create-env.
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${ICECC_WRAPPER+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in compilerwrapper
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_WRAPPER+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_WRAPPER in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_WRAPPER="$ICECC_WRAPPER" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_WRAPPER="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_WRAPPER=$ac_cv_path_ICECC_WRAPPER
|
|
if test -n "$ICECC_WRAPPER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_WRAPPER" >&5
|
|
$as_echo "$ICECC_WRAPPER" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ICECC_WRAPPER" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !ICECC_WRAPPER! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ICECC_WRAPPER!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xICECC_WRAPPER" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ICECC_WRAPPER from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of ICECC_WRAPPER from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in compilerwrapper
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_WRAPPER+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_WRAPPER in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_WRAPPER="$ICECC_WRAPPER" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_WRAPPER="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_WRAPPER=$ac_cv_path_ICECC_WRAPPER
|
|
if test -n "$ICECC_WRAPPER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_WRAPPER" >&5
|
|
$as_echo "$ICECC_WRAPPER" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$ICECC_WRAPPER" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$ICECC_WRAPPER" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool ICECC_WRAPPER= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool ICECC_WRAPPER= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_WRAPPER" >&5
|
|
$as_echo_n "checking for ICECC_WRAPPER... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$ICECC_WRAPPER"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ICECC_WRAPPER=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool ICECC_WRAPPER=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_ICECC_WRAPPER+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $ICECC_WRAPPER in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_ICECC_WRAPPER="$ICECC_WRAPPER" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_ICECC_WRAPPER="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
ICECC_WRAPPER=$ac_cv_path_ICECC_WRAPPER
|
|
if test -n "$ICECC_WRAPPER"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ICECC_WRAPPER" >&5
|
|
$as_echo "$ICECC_WRAPPER" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$ICECC_WRAPPER" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ICECC_WRAPPER=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool ICECC_WRAPPER=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ICECC_WRAPPER" >&5
|
|
$as_echo_n "checking for ICECC_WRAPPER... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool ICECC_WRAPPER=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$ICECC_WRAPPER" = x; then
|
|
as_fn_error $? "Could not find required tool for ICECC_WRAPPER" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
|
|
&& ${ICECC_CREATE_ENV} --clang ${CC} ${ICECC_WRAPPER} > ${icecc_create_env_log} 2>&1 )
|
|
if test "$?" != "0"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
|
|
$as_echo "$as_me: icecc-create-env output:" >&6;}
|
|
cat ${icecc_create_env_log}
|
|
as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
|
|
fi
|
|
|
|
else
|
|
as_fn_error $? "Can only create icecc compiler packages for toolchain types gcc and clang" "$LINENO" 5
|
|
fi
|
|
PATH="$old_path"
|
|
# The bundle with the compiler gets a name based on checksums. Parse log file
|
|
# to find it.
|
|
ICECC_ENV_BUNDLE_BASENAME="`${SED} -n '/^creating/s/creating //p' ${icecc_create_env_log}`"
|
|
ICECC_ENV_BUNDLE="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/${ICECC_ENV_BUNDLE_BASENAME}"
|
|
if test ! -f ${ICECC_ENV_BUNDLE}; then
|
|
as_fn_error $? "icecc-create-env did not produce an environment ${ICECC_ENV_BUNDLE}" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for icecc build environment for target compiler" >&5
|
|
$as_echo_n "checking for icecc build environment for target compiler... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ICECC_ENV_BUNDLE}" >&5
|
|
$as_echo "${ICECC_ENV_BUNDLE}" >&6; }
|
|
ICECC="ICECC_VERSION=${ICECC_ENV_BUNDLE} ICECC_CC=${CC} ICECC_CXX=${CXX} ${ICECC_CMD}"
|
|
|
|
if test "x${COMPILE_TYPE}" = "xcross"; then
|
|
# If cross compiling, create a separate env package for the build compiler
|
|
# Assume "gcc" or "cc" is gcc and "clang" is clang. Otherwise bail.
|
|
icecc_create_env_log_build="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/icecc_create_env_build.log"
|
|
if test "x${BUILD_CC##*/}" = "xgcc" || test "x${BUILD_CC##*/}" = "xcc"; then
|
|
|
|
( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
|
|
&& ${ICECC_CREATE_ENV} ${icecc_gcc_arg} ${BUILD_CC} ${BUILD_CXX} > \
|
|
${icecc_create_env_log_build} 2>&1 )
|
|
if test "$?" != "0"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
|
|
$as_echo "$as_me: icecc-create-env output:" >&6;}
|
|
cat \
|
|
${icecc_create_env_log_build}
|
|
as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
|
|
fi
|
|
|
|
elif test "x${BUILD_CC##*/}" = "xclang"; then
|
|
|
|
( cd ${CONFIGURESUPPORT_OUTPUTDIR}/icecc \
|
|
&& ${ICECC_CREATE_ENV} --clang ${BUILD_CC} ${ICECC_WRAPPER} > ${icecc_create_env_log_build} 2>&1 )
|
|
if test "$?" != "0"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: icecc-create-env output:" >&5
|
|
$as_echo "$as_me: icecc-create-env output:" >&6;}
|
|
cat ${icecc_create_env_log_build}
|
|
as_fn_error $? "Failed to create icecc compiler environment" "$LINENO" 5
|
|
fi
|
|
|
|
else
|
|
as_fn_error $? "Cannot create icecc compiler package for ${BUILD_CC}" "$LINENO" 5
|
|
fi
|
|
ICECC_ENV_BUNDLE_BASENAME="`${SED} -n '/^creating/s/creating //p' ${icecc_create_env_log_build}`"
|
|
ICECC_ENV_BUNDLE="${CONFIGURESUPPORT_OUTPUTDIR}/icecc/${ICECC_ENV_BUNDLE_BASENAME}"
|
|
if test ! -f ${ICECC_ENV_BUNDLE}; then
|
|
as_fn_error $? "icecc-create-env did not produce an environment ${ICECC_ENV_BUNDLE}" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for icecc build environment for build compiler" >&5
|
|
$as_echo_n "checking for icecc build environment for build compiler... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${ICECC_ENV_BUNDLE}" >&5
|
|
$as_echo "${ICECC_ENV_BUNDLE}" >&6; }
|
|
BUILD_ICECC="ICECC_VERSION=${ICECC_ENV_BUNDLE} ICECC_CC=${BUILD_CC} \
|
|
ICECC_CXX=${BUILD_CXX} ${ICECC_CMD}"
|
|
else
|
|
BUILD_ICECC="${ICECC}"
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
# Can the C/C++ compiler use precompiled headers?
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# Can the C/C++ compiler use precompiled headers?
|
|
#
|
|
# Check whether --enable-precompiled-headers was given.
|
|
if test "${enable_precompiled_headers+set}" = set; then :
|
|
enableval=$enable_precompiled_headers; ENABLE_PRECOMPH=${enable_precompiled_headers}
|
|
else
|
|
ENABLE_PRECOMPH=yes
|
|
fi
|
|
|
|
|
|
USE_PRECOMPILED_HEADER=true
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking If precompiled header is enabled" >&5
|
|
$as_echo_n "checking If precompiled header is enabled... " >&6; }
|
|
if test "x$ENABLE_PRECOMPH" = xno; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, forced" >&5
|
|
$as_echo "no, forced" >&6; }
|
|
USE_PRECOMPILED_HEADER=false
|
|
elif test "x$ICECC" != "x"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, does not work effectively with icecc" >&5
|
|
$as_echo "no, does not work effectively with icecc" >&6; }
|
|
USE_PRECOMPILED_HEADER=false
|
|
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, does not work with Solaris Studio" >&5
|
|
$as_echo "no, does not work with Solaris Studio" >&6; }
|
|
USE_PRECOMPILED_HEADER=false
|
|
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, does not work with xlc" >&5
|
|
$as_echo "no, does not work with xlc" >&6; }
|
|
USE_PRECOMPILED_HEADER=false
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
|
|
if test "x$ENABLE_PRECOMPH" = xyes; then
|
|
# Check that the compiler actually supports precomp headers.
|
|
if test "x$TOOLCHAIN_TYPE" = xgcc; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5
|
|
$as_echo_n "checking that precompiled headers work... " >&6; }
|
|
echo "int alfa();" > conftest.h
|
|
$CXX -x c++-header conftest.h -o conftest.hpp.gch 2>&5 >&5
|
|
if test ! -f conftest.hpp.gch; then
|
|
USE_PRECOMPILED_HEADER=false
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
fi
|
|
$RM conftest.h conftest.hpp.gch
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
|
|
# Setup use of ccache, if available
|
|
|
|
# Check whether --enable-ccache was given.
|
|
if test "${enable_ccache+set}" = set; then :
|
|
enableval=$enable_ccache;
|
|
fi
|
|
|
|
|
|
CCACHE_STATUS=
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
|
|
$as_echo_n "checking is ccache enabled... " >&6; }
|
|
if test "x$enable_ccache" = xyes; then
|
|
if test "x$TOOLCHAIN_TYPE" = "xgcc" -o "x$TOOLCHAIN_TYPE" = "xclang"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
OLD_PATH="$PATH"
|
|
if test "x$TOOLCHAIN_PATH" != x; then
|
|
PATH=$TOOLCHAIN_PATH:$PATH
|
|
fi
|
|
|
|
|
|
|
|
# Publish this variable in the help.
|
|
|
|
|
|
if [ -z "${CCACHE+x}" ]; then
|
|
# The variable is not set by user, try to locate tool using the code snippet
|
|
for ac_prog in ccache
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CCACHE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CCACHE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CCACHE=$ac_cv_path_CCACHE
|
|
if test -n "$CCACHE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
|
|
$as_echo "$CCACHE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CCACHE" && break
|
|
done
|
|
|
|
else
|
|
# The variable is set, but is it from the command line or the environment?
|
|
|
|
# Try to remove the string !CCACHE! from our list.
|
|
try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CCACHE!/}
|
|
if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
|
|
# If it failed, the variable was not from the command line. Ignore it,
|
|
# but warn the user (except for BASH, which is always set by the calling BASH).
|
|
if test "xCCACHE" != xBASH; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
|
|
$as_echo "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
|
|
fi
|
|
# Try to locate tool using the code snippet
|
|
for ac_prog in ccache
|
|
do
|
|
# Extract the first word of "$ac_prog", so it can be a program name with args.
|
|
set dummy $ac_prog; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CCACHE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CCACHE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CCACHE=$ac_cv_path_CCACHE
|
|
if test -n "$CCACHE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
|
|
$as_echo "$CCACHE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
test -n "$CCACHE" && break
|
|
done
|
|
|
|
else
|
|
# If it succeeded, then it was overridden by the user. We will use it
|
|
# for the tool.
|
|
|
|
# First remove it from the list of overridden variables, so we can test
|
|
# for unknown variables in the end.
|
|
CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
|
|
|
|
# Check if we try to supply an empty value
|
|
if test "x$CCACHE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Setting user supplied tool CCACHE= (no value)" >&5
|
|
$as_echo "$as_me: Setting user supplied tool CCACHE= (no value)" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
|
|
$as_echo_n "checking for CCACHE... " >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
|
|
$as_echo "disabled" >&6; }
|
|
else
|
|
# Check if the provided tool contains a complete path.
|
|
tool_specified="$CCACHE"
|
|
tool_basename="${tool_specified##*/}"
|
|
if test "x$tool_basename" = "x$tool_specified"; then
|
|
# A command without a complete path is provided, search $PATH.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
|
|
$as_echo "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
|
|
# Extract the first word of "$tool_basename", so it can be a program name with args.
|
|
set dummy $tool_basename; ac_word=$2
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
|
|
$as_echo_n "checking for $ac_word... " >&6; }
|
|
if ${ac_cv_path_CCACHE+:} false; then :
|
|
$as_echo_n "(cached) " >&6
|
|
else
|
|
case $CCACHE in
|
|
[\\/]* | ?:[\\/]*)
|
|
ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
|
|
;;
|
|
*)
|
|
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
for ac_exec_ext in '' $ac_executable_extensions; do
|
|
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
|
ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
|
break 2
|
|
fi
|
|
done
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
fi
|
|
CCACHE=$ac_cv_path_CCACHE
|
|
if test -n "$CCACHE"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
|
|
$as_echo "$CCACHE" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
fi
|
|
|
|
|
|
if test "x$CCACHE" = x; then
|
|
as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
|
|
fi
|
|
else
|
|
# Otherwise we believe it is a complete path. Use it as it is.
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
|
|
$as_echo "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
|
|
$as_echo_n "checking for CCACHE... " >&6; }
|
|
if test ! -x "$tool_specified"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
|
|
$as_echo "not found" >&6; }
|
|
as_fn_error $? "User supplied tool CCACHE=$tool_specified does not exist or is not executable" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
|
|
$as_echo "$tool_specified" >&6; }
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
if test "x$CCACHE" = x; then
|
|
as_fn_error $? "Could not find required tool for CCACHE" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
PATH="$OLD_PATH"
|
|
CCACHE_VERSION=`$CCACHE --version | head -n1 | $SED 's/[A-Za-z ]*//'`
|
|
CCACHE_STATUS="Active ($CCACHE_VERSION)"
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: ccache is not supported with toolchain type $TOOLCHAIN_TYPE" >&5
|
|
$as_echo "$as_me: WARNING: ccache is not supported with toolchain type $TOOLCHAIN_TYPE" >&2;}
|
|
fi
|
|
elif test "x$enable_ccache" = xno; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
|
|
$as_echo "no, explicitly disabled" >&6; }
|
|
CCACHE_STATUS="Disabled"
|
|
elif test "x$enable_ccache" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
|
|
$as_echo "unknown" >&6; }
|
|
as_fn_error $? "--enable-ccache does not accept any parameters" "$LINENO" 5
|
|
fi
|
|
|
|
|
|
|
|
# Check whether --with-ccache-dir was given.
|
|
if test "${with_ccache_dir+set}" = set; then :
|
|
withval=$with_ccache_dir;
|
|
fi
|
|
|
|
|
|
if test "x$with_ccache_dir" != x; then
|
|
# When using a non home ccache directory, assume the use is to share ccache files
|
|
# with other users. Thus change the umask.
|
|
SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002"
|
|
if test "x$CCACHE" = x; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&5
|
|
$as_echo "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&2;}
|
|
fi
|
|
fi
|
|
|
|
if test "x$CCACHE" != x; then
|
|
|
|
if test "x$CCACHE" != x; then
|
|
if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
|
|
HAS_BAD_CCACHE=`$ECHO $CCACHE_VERSION | \
|
|
$GREP -e '^1\.' -e '^2\.' -e '^3\.0\.' -e '^3\.1\.'`
|
|
if test "x$HAS_BAD_CCACHE" != "x"; then
|
|
as_fn_error $? "On macosx, ccache 3.2 or later is required, found $CCACHE_VERSION" "$LINENO" 5
|
|
fi
|
|
fi
|
|
if test "x$USE_PRECOMPILED_HEADER" = "xtrue"; then
|
|
HAS_BAD_CCACHE=`$ECHO $CCACHE_VERSION | \
|
|
$GREP -e '^1.*' -e '^2.*' -e '^3\.0.*' -e '^3\.1\.[0123]$'`
|
|
if test "x$HAS_BAD_CCACHE" != "x"; then
|
|
as_fn_error $? "Precompiled headers requires ccache 3.1.4 or later, found $CCACHE_VERSION" "$LINENO" 5
|
|
fi
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5
|
|
$as_echo_n "checking if C-compiler supports ccache precompiled headers... " >&6; }
|
|
CCACHE_PRECOMP_FLAG="-fpch-preprocess"
|
|
PUSHED_FLAGS="$CXXFLAGS"
|
|
CXXFLAGS="$CCACHE_PRECOMP_FLAG $CXXFLAGS"
|
|
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
|
/* end confdefs.h. */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
|
|
;
|
|
return 0;
|
|
}
|
|
_ACEOF
|
|
if ac_fn_cxx_try_compile "$LINENO"; then :
|
|
CC_KNOWS_CCACHE_TRICK=yes
|
|
else
|
|
CC_KNOWS_CCACHE_TRICK=no
|
|
fi
|
|
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
|
|
CXXFLAGS="$PUSHED_FLAGS"
|
|
if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
|
$as_echo "yes" >&6; }
|
|
CFLAGS_CCACHE="$CCACHE_PRECOMP_FLAG"
|
|
|
|
CCACHE_SLOPPINESS=pch_defines,time_macros
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
|
|
$as_echo "no" >&6; }
|
|
as_fn_error $? "Cannot use ccache with precompiled headers without compiler support for $CCACHE_PRECOMP_FLAG" "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
CCACHE="CCACHE_COMPRESS=1 $SET_CCACHE_DIR \
|
|
CCACHE_SLOPPINESS=$CCACHE_SLOPPINESS CCACHE_BASEDIR=$TOPDIR $CCACHE"
|
|
|
|
if test "x$SET_CCACHE_DIR" != x; then
|
|
mkdir -p $CCACHE_DIR > /dev/null 2>&1
|
|
chmod a+rwxs $CCACHE_DIR > /dev/null 2>&1
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
###############################################################################
|
|
#
|
|
# And now the finish...
|
|
#
|
|
###############################################################################
|
|
|
|
# Check for some common pitfalls
|
|
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
|
file_to_test="$SRC_ROOT/LICENSE"
|
|
if test `$STAT -c '%a' "$file_to_test"` -lt 400; then
|
|
as_fn_error $? "Bad file permissions on src files. This is usually caused by cloning the repositories with a non cygwin hg in a directory not created in cygwin." "$LINENO" 5
|
|
fi
|
|
fi
|
|
|
|
|
|
# Did user specify any unknown variables?
|
|
|
|
if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
|
|
# Replace the separating ! with spaces before presenting for end user.
|
|
unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
|
|
$as_echo "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
|
|
fi
|
|
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
|
|
$as_echo_n "checking if build directory is on local disk... " >&6; }
|
|
|
|
# df -l lists only local disks; if the given directory is not found then
|
|
# a non-zero exit code is given
|
|
if test "x$DF" = x; then
|
|
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
|
# msys does not have df; use Windows "net use" instead.
|
|
IS_NETWORK_DISK=`net use | grep \`pwd -W | cut -d ":" -f 1 | tr a-z A-Z\`:`
|
|
if test "x$IS_NETWORK_DISK" = x; then
|
|
OUTPUT_DIR_IS_LOCAL="yes"
|
|
else
|
|
OUTPUT_DIR_IS_LOCAL="no"
|
|
fi
|
|
else
|
|
# No df here, say it's local
|
|
OUTPUT_DIR_IS_LOCAL="yes"
|
|
fi
|
|
else
|
|
if $DF -l $OUTPUT_ROOT > /dev/null 2>&1; then
|
|
OUTPUT_DIR_IS_LOCAL="yes"
|
|
else
|
|
OUTPUT_DIR_IS_LOCAL="no"
|
|
fi
|
|
fi
|
|
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5
|
|
$as_echo "$OUTPUT_DIR_IS_LOCAL" >&6; }
|
|
|
|
|
|
|
|
# Check if the user has any old-style ALT_ variables set.
|
|
FOUND_ALT_VARIABLES=`env | grep ^ALT_`
|
|
|
|
# Before generating output files, test if they exist. If they do, this is a reconfigure.
|
|
# Since we can't properly handle the dependencies for this, warn the user about the situation
|
|
if test -e $OUTPUT_ROOT/spec.gmk; then
|
|
IS_RECONFIGURE=yes
|
|
else
|
|
IS_RECONFIGURE=no
|
|
fi
|
|
|
|
|
|
# At the end, call the custom hook. (Dummy macro if no custom sources available)
|
|
|
|
|
|
# This needs to be done after CUSTOM_LATE_HOOK since we can setup custom features.
|
|
|
|
# Keep feature lists sorted and free of duplicates
|
|
JVM_FEATURES_server="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_server | $SORT -u))"
|
|
JVM_FEATURES_client="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_client | $SORT -u))"
|
|
JVM_FEATURES_core="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_core | $SORT -u))"
|
|
JVM_FEATURES_minimal="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_minimal | $SORT -u))"
|
|
JVM_FEATURES_zero="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_zero | $SORT -u))"
|
|
JVM_FEATURES_zeroshark="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_zeroshark | $SORT -u))"
|
|
JVM_FEATURES_custom="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_custom | $SORT -u))"
|
|
|
|
# Validate features
|
|
for variant in $JVM_VARIANTS; do
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking JVM features for JVM variant '$variant'" >&5
|
|
$as_echo_n "checking JVM features for JVM variant '$variant'... " >&6; }
|
|
features_var_name=JVM_FEATURES_$variant
|
|
JVM_FEATURES_TO_TEST=${!features_var_name}
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JVM_FEATURES_TO_TEST" >&5
|
|
$as_echo "$JVM_FEATURES_TO_TEST" >&6; }
|
|
NEEDLE=${VALID_JVM_FEATURES// /$'\n'}
|
|
STACK=${JVM_FEATURES_TO_TEST// /$'\n'}
|
|
INVALID_FEATURES=`$GREP -Fvx "${NEEDLE}" <<< "${STACK}"`
|
|
if test "x$INVALID_FEATURES" != x; then
|
|
as_fn_error $? "Invalid JVM feature(s): $INVALID_FEATURES" "$LINENO" 5
|
|
fi
|
|
done
|
|
|
|
|
|
# We're messing a bit with internal autoconf variables to put the config.status
|
|
# in the output directory instead of the current directory.
|
|
CONFIG_STATUS="$CONFIGURESUPPORT_OUTPUTDIR/config.status"
|
|
|
|
# Create the actual output files. Now the main work of configure is done.
|
|
cat >confcache <<\_ACEOF
|
|
# This file is a shell script that caches the results of configure
|
|
# tests run on this system so they can be shared between configure
|
|
# scripts and configure runs, see configure's option --config-cache.
|
|
# It is not useful on other systems. If it contains results you don't
|
|
# want to keep, you may remove or edit it.
|
|
#
|
|
# config.status only pays attention to the cache file if you give it
|
|
# the --recheck option to rerun configure.
|
|
#
|
|
# `ac_cv_env_foo' variables (set or unset) will be overridden when
|
|
# loading this file, other *unset* `ac_cv_foo' will be assigned the
|
|
# following values.
|
|
|
|
_ACEOF
|
|
|
|
# The following way of writing the cache mishandles newlines in values,
|
|
# but we know of no workaround that is simple, portable, and efficient.
|
|
# So, we kill variables containing newlines.
|
|
# Ultrix sh set writes to stderr and can't be redirected directly,
|
|
# and sets the high bit in the cache file unless we assign to the vars.
|
|
(
|
|
for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
|
|
eval ac_val=\$$ac_var
|
|
case $ac_val in #(
|
|
*${as_nl}*)
|
|
case $ac_var in #(
|
|
*_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
|
|
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
|
|
esac
|
|
case $ac_var in #(
|
|
_ | IFS | as_nl) ;; #(
|
|
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
|
|
*) { eval $ac_var=; unset $ac_var;} ;;
|
|
esac ;;
|
|
esac
|
|
done
|
|
|
|
(set) 2>&1 |
|
|
case $as_nl`(ac_space=' '; set) 2>&1` in #(
|
|
*${as_nl}ac_space=\ *)
|
|
# `set' does not quote correctly, so add quotes: double-quote
|
|
# substitution turns \\\\ into \\, and sed turns \\ into \.
|
|
sed -n \
|
|
"s/'/'\\\\''/g;
|
|
s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
|
|
;; #(
|
|
*)
|
|
# `set' quotes correctly as required by POSIX, so do not add quotes.
|
|
sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
|
|
;;
|
|
esac |
|
|
sort
|
|
) |
|
|
sed '
|
|
/^ac_cv_env_/b end
|
|
t clear
|
|
:clear
|
|
s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
|
|
t end
|
|
s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
|
|
:end' >>confcache
|
|
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
|
|
if test -w "$cache_file"; then
|
|
if test "x$cache_file" != "x/dev/null"; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
|
|
$as_echo "$as_me: updating cache $cache_file" >&6;}
|
|
if test ! -f "$cache_file" || test -h "$cache_file"; then
|
|
cat confcache >"$cache_file"
|
|
else
|
|
case $cache_file in #(
|
|
*/* | ?:*)
|
|
mv -f confcache "$cache_file"$$ &&
|
|
mv -f "$cache_file"$$ "$cache_file" ;; #(
|
|
*)
|
|
mv -f confcache "$cache_file" ;;
|
|
esac
|
|
fi
|
|
fi
|
|
else
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
|
|
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
|
|
fi
|
|
fi
|
|
rm -f confcache
|
|
|
|
test "x$prefix" = xNONE && prefix=$ac_default_prefix
|
|
# Let make expand exec_prefix.
|
|
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
|
|
|
|
# Transform confdefs.h into DEFS.
|
|
# Protect against shell expansion while executing Makefile rules.
|
|
# Protect against Makefile macro expansion.
|
|
#
|
|
# If the first sed substitution is executed (which looks for macros that
|
|
# take arguments), then branch to the quote section. Otherwise,
|
|
# look for a macro that doesn't take arguments.
|
|
ac_script='
|
|
:mline
|
|
/\\$/{
|
|
N
|
|
s,\\\n,,
|
|
b mline
|
|
}
|
|
t clear
|
|
:clear
|
|
s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g
|
|
t quote
|
|
s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g
|
|
t quote
|
|
b any
|
|
:quote
|
|
s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g
|
|
s/\[/\\&/g
|
|
s/\]/\\&/g
|
|
s/\$/$$/g
|
|
H
|
|
:any
|
|
${
|
|
g
|
|
s/^\n//
|
|
s/\n/ /g
|
|
p
|
|
}
|
|
'
|
|
DEFS=`sed -n "$ac_script" confdefs.h`
|
|
|
|
|
|
ac_libobjs=
|
|
ac_ltlibobjs=
|
|
U=
|
|
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
|
|
# 1. Remove the extension, and $U if already installed.
|
|
ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
|
|
ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
|
|
# 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
|
|
# will be set to the directory where LIBOBJS objects are built.
|
|
as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
|
|
as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
|
|
done
|
|
LIBOBJS=$ac_libobjs
|
|
|
|
LTLIBOBJS=$ac_ltlibobjs
|
|
|
|
|
|
|
|
: "${CONFIG_STATUS=./config.status}"
|
|
ac_write_fail=0
|
|
ac_clean_files_save=$ac_clean_files
|
|
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
|
|
$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
|
|
as_write_fail=0
|
|
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
|
|
#! $SHELL
|
|
# Generated by $as_me.
|
|
# Run this file to recreate the current configuration.
|
|
# Compiler output produced by configure, useful for debugging
|
|
# configure, is in config.log if it exists.
|
|
|
|
debug=false
|
|
ac_cs_recheck=false
|
|
ac_cs_silent=false
|
|
|
|
SHELL=\${CONFIG_SHELL-$SHELL}
|
|
export SHELL
|
|
_ASEOF
|
|
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
|
|
## -------------------- ##
|
|
## M4sh Initialization. ##
|
|
## -------------------- ##
|
|
|
|
# Be more Bourne compatible
|
|
DUALCASE=1; export DUALCASE # for MKS sh
|
|
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
|
|
emulate sh
|
|
NULLCMD=:
|
|
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
|
|
# is contrary to our usage. Disable this feature.
|
|
alias -g '${1+"$@"}'='"$@"'
|
|
setopt NO_GLOB_SUBST
|
|
else
|
|
case `(set -o) 2>/dev/null` in #(
|
|
*posix*) :
|
|
set -o posix ;; #(
|
|
*) :
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
|
|
as_nl='
|
|
'
|
|
export as_nl
|
|
# Printing a long string crashes Solaris 7 /usr/bin/printf.
|
|
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
|
|
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
|
|
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
|
|
# Prefer a ksh shell builtin over an external printf program on Solaris,
|
|
# but without wasting forks for bash or zsh.
|
|
if test -z "$BASH_VERSION$ZSH_VERSION" \
|
|
&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
|
|
as_echo='print -r --'
|
|
as_echo_n='print -rn --'
|
|
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
|
|
as_echo='printf %s\n'
|
|
as_echo_n='printf %s'
|
|
else
|
|
if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
|
|
as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
|
|
as_echo_n='/usr/ucb/echo -n'
|
|
else
|
|
as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
|
|
as_echo_n_body='eval
|
|
arg=$1;
|
|
case $arg in #(
|
|
*"$as_nl"*)
|
|
expr "X$arg" : "X\\(.*\\)$as_nl";
|
|
arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
|
|
esac;
|
|
expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
|
|
'
|
|
export as_echo_n_body
|
|
as_echo_n='sh -c $as_echo_n_body as_echo'
|
|
fi
|
|
export as_echo_body
|
|
as_echo='sh -c $as_echo_body as_echo'
|
|
fi
|
|
|
|
# The user is always right.
|
|
if test "${PATH_SEPARATOR+set}" != set; then
|
|
PATH_SEPARATOR=:
|
|
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
|
|
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
|
|
PATH_SEPARATOR=';'
|
|
}
|
|
fi
|
|
|
|
|
|
# IFS
|
|
# We need space, tab and new line, in precisely that order. Quoting is
|
|
# there to prevent editors from complaining about space-tab.
|
|
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
|
|
# splitting by setting IFS to empty value.)
|
|
IFS=" "" $as_nl"
|
|
|
|
# Find who we are. Look in the path if we contain no directory separator.
|
|
as_myself=
|
|
case $0 in #((
|
|
*[\\/]* ) as_myself=$0 ;;
|
|
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
for as_dir in $PATH
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
|
|
done
|
|
IFS=$as_save_IFS
|
|
|
|
;;
|
|
esac
|
|
# We did not find ourselves, most probably we were run as `sh COMMAND'
|
|
# in which case we are not to be found in the path.
|
|
if test "x$as_myself" = x; then
|
|
as_myself=$0
|
|
fi
|
|
if test ! -f "$as_myself"; then
|
|
$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
|
|
exit 1
|
|
fi
|
|
|
|
# Unset variables that we do not need and which cause bugs (e.g. in
|
|
# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
|
|
# suppresses any "Segmentation fault" message there. '((' could
|
|
# trigger a bug in pdksh 5.2.14.
|
|
for as_var in BASH_ENV ENV MAIL MAILPATH
|
|
do eval test x\${$as_var+set} = xset \
|
|
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
|
|
done
|
|
PS1='$ '
|
|
PS2='> '
|
|
PS4='+ '
|
|
|
|
# NLS nuisances.
|
|
LC_ALL=C
|
|
export LC_ALL
|
|
LANGUAGE=C
|
|
export LANGUAGE
|
|
|
|
# CDPATH.
|
|
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
|
|
|
|
|
|
# as_fn_error STATUS ERROR [LINENO LOG_FD]
|
|
# ----------------------------------------
|
|
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
|
|
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
|
|
# script with STATUS, using 1 if that was 0.
|
|
as_fn_error ()
|
|
{
|
|
as_status=$1; test $as_status -eq 0 && as_status=1
|
|
if test "$4"; then
|
|
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
|
|
$as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
|
|
fi
|
|
$as_echo "$as_me: error: $2" >&2
|
|
as_fn_exit $as_status
|
|
} # as_fn_error
|
|
|
|
|
|
# as_fn_set_status STATUS
|
|
# -----------------------
|
|
# Set $? to STATUS, without forking.
|
|
as_fn_set_status ()
|
|
{
|
|
return $1
|
|
} # as_fn_set_status
|
|
|
|
# as_fn_exit STATUS
|
|
# -----------------
|
|
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
|
|
as_fn_exit ()
|
|
{
|
|
set +e
|
|
as_fn_set_status $1
|
|
exit $1
|
|
} # as_fn_exit
|
|
|
|
# as_fn_unset VAR
|
|
# ---------------
|
|
# Portably unset VAR.
|
|
as_fn_unset ()
|
|
{
|
|
{ eval $1=; unset $1;}
|
|
}
|
|
as_unset=as_fn_unset
|
|
# as_fn_append VAR VALUE
|
|
# ----------------------
|
|
# Append the text in VALUE to the end of the definition contained in VAR. Take
|
|
# advantage of any shell optimizations that allow amortized linear growth over
|
|
# repeated appends, instead of the typical quadratic growth present in naive
|
|
# implementations.
|
|
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
|
|
eval 'as_fn_append ()
|
|
{
|
|
eval $1+=\$2
|
|
}'
|
|
else
|
|
as_fn_append ()
|
|
{
|
|
eval $1=\$$1\$2
|
|
}
|
|
fi # as_fn_append
|
|
|
|
# as_fn_arith ARG...
|
|
# ------------------
|
|
# Perform arithmetic evaluation on the ARGs, and store the result in the
|
|
# global $as_val. Take advantage of shells that can avoid forks. The arguments
|
|
# must be portable across $(()) and expr.
|
|
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
|
|
eval 'as_fn_arith ()
|
|
{
|
|
as_val=$(( $* ))
|
|
}'
|
|
else
|
|
as_fn_arith ()
|
|
{
|
|
as_val=`expr "$@" || test $? -eq 1`
|
|
}
|
|
fi # as_fn_arith
|
|
|
|
|
|
if expr a : '\(a\)' >/dev/null 2>&1 &&
|
|
test "X`expr 00001 : '.*\(...\)'`" = X001; then
|
|
as_expr=expr
|
|
else
|
|
as_expr=false
|
|
fi
|
|
|
|
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
|
|
as_basename=basename
|
|
else
|
|
as_basename=false
|
|
fi
|
|
|
|
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
|
|
as_dirname=dirname
|
|
else
|
|
as_dirname=false
|
|
fi
|
|
|
|
as_me=`$as_basename -- "$0" ||
|
|
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
|
|
X"$0" : 'X\(//\)$' \| \
|
|
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
|
|
$as_echo X/"$0" |
|
|
sed '/^.*\/\([^/][^/]*\)\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\/\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\/\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q'`
|
|
|
|
# Avoid depending upon Character Ranges.
|
|
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
|
|
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
|
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
|
|
as_cr_digits='0123456789'
|
|
as_cr_alnum=$as_cr_Letters$as_cr_digits
|
|
|
|
ECHO_C= ECHO_N= ECHO_T=
|
|
case `echo -n x` in #(((((
|
|
-n*)
|
|
case `echo 'xy\c'` in
|
|
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
|
|
xy) ECHO_C='\c';;
|
|
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
|
|
ECHO_T=' ';;
|
|
esac;;
|
|
*)
|
|
ECHO_N='-n';;
|
|
esac
|
|
|
|
rm -f conf$$ conf$$.exe conf$$.file
|
|
if test -d conf$$.dir; then
|
|
rm -f conf$$.dir/conf$$.file
|
|
else
|
|
rm -f conf$$.dir
|
|
mkdir conf$$.dir 2>/dev/null
|
|
fi
|
|
if (echo >conf$$.file) 2>/dev/null; then
|
|
if ln -s conf$$.file conf$$ 2>/dev/null; then
|
|
as_ln_s='ln -s'
|
|
# ... but there are two gotchas:
|
|
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
|
|
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
|
|
# In both cases, we have to default to `cp -pR'.
|
|
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
|
|
as_ln_s='cp -pR'
|
|
elif ln conf$$.file conf$$ 2>/dev/null; then
|
|
as_ln_s=ln
|
|
else
|
|
as_ln_s='cp -pR'
|
|
fi
|
|
else
|
|
as_ln_s='cp -pR'
|
|
fi
|
|
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
|
|
rmdir conf$$.dir 2>/dev/null
|
|
|
|
|
|
# as_fn_mkdir_p
|
|
# -------------
|
|
# Create "$as_dir" as a directory, including parents if necessary.
|
|
as_fn_mkdir_p ()
|
|
{
|
|
|
|
case $as_dir in #(
|
|
-*) as_dir=./$as_dir;;
|
|
esac
|
|
test -d "$as_dir" || eval $as_mkdir_p || {
|
|
as_dirs=
|
|
while :; do
|
|
case $as_dir in #(
|
|
*\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
|
|
*) as_qdir=$as_dir;;
|
|
esac
|
|
as_dirs="'$as_qdir' $as_dirs"
|
|
as_dir=`$as_dirname -- "$as_dir" ||
|
|
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
|
|
X"$as_dir" : 'X\(//\)[^/]' \| \
|
|
X"$as_dir" : 'X\(//\)$' \| \
|
|
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
|
|
$as_echo X"$as_dir" |
|
|
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)[^/].*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q'`
|
|
test -d "$as_dir" && break
|
|
done
|
|
test -z "$as_dirs" || eval "mkdir $as_dirs"
|
|
} || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
|
|
|
|
|
|
} # as_fn_mkdir_p
|
|
if mkdir -p . 2>/dev/null; then
|
|
as_mkdir_p='mkdir -p "$as_dir"'
|
|
else
|
|
test -d ./-p && rmdir ./-p
|
|
as_mkdir_p=false
|
|
fi
|
|
|
|
|
|
# as_fn_executable_p FILE
|
|
# -----------------------
|
|
# Test if FILE is an executable regular file.
|
|
as_fn_executable_p ()
|
|
{
|
|
test -f "$1" && test -x "$1"
|
|
} # as_fn_executable_p
|
|
as_test_x='test -x'
|
|
as_executable_p=as_fn_executable_p
|
|
|
|
# Sed expression to map a string onto a valid CPP name.
|
|
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
|
|
|
|
# Sed expression to map a string onto a valid variable name.
|
|
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
|
|
|
|
|
|
exec 6>&1
|
|
## ----------------------------------- ##
|
|
## Main body of $CONFIG_STATUS script. ##
|
|
## ----------------------------------- ##
|
|
_ASEOF
|
|
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
|
|
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
# Save the log message, to keep $0 and so on meaningful, and to
|
|
# report actual input values of CONFIG_FILES etc. instead of their
|
|
# values after options handling.
|
|
ac_log="
|
|
This file was extended by OpenJDK $as_me jdk9, which was
|
|
generated by GNU Autoconf 2.69. Invocation command line was
|
|
|
|
CONFIG_FILES = $CONFIG_FILES
|
|
CONFIG_HEADERS = $CONFIG_HEADERS
|
|
CONFIG_LINKS = $CONFIG_LINKS
|
|
CONFIG_COMMANDS = $CONFIG_COMMANDS
|
|
$ $0 $@
|
|
|
|
on `(hostname || uname -n) 2>/dev/null | sed 1q`
|
|
"
|
|
|
|
_ACEOF
|
|
|
|
case $ac_config_files in *"
|
|
"*) set x $ac_config_files; shift; ac_config_files=$*;;
|
|
esac
|
|
|
|
|
|
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
# Files that config.status was made for.
|
|
config_files="$ac_config_files"
|
|
|
|
_ACEOF
|
|
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
ac_cs_usage="\
|
|
\`$as_me' instantiates files and other configuration actions
|
|
from templates according to the current configuration. Unless the files
|
|
and actions are specified as TAGs, all are instantiated by default.
|
|
|
|
Usage: $0 [OPTION]... [TAG]...
|
|
|
|
-h, --help print this help, then exit
|
|
-V, --version print version number and configuration settings, then exit
|
|
--config print configuration, then exit
|
|
-q, --quiet, --silent
|
|
do not print progress messages
|
|
-d, --debug don't remove temporary files
|
|
--recheck update $as_me by reconfiguring in the same conditions
|
|
--file=FILE[:TEMPLATE]
|
|
instantiate the configuration file FILE
|
|
|
|
Configuration files:
|
|
$config_files
|
|
|
|
Report bugs to <build-dev@openjdk.java.net>.
|
|
OpenJDK home page: <http://openjdk.java.net>."
|
|
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
|
|
ac_cs_version="\\
|
|
OpenJDK config.status jdk9
|
|
configured by $0, generated by GNU Autoconf 2.69,
|
|
with options \\"\$ac_cs_config\\"
|
|
|
|
Copyright (C) 2012 Free Software Foundation, Inc.
|
|
This config.status script is free software; the Free Software Foundation
|
|
gives unlimited permission to copy, distribute and modify it."
|
|
|
|
ac_pwd='$ac_pwd'
|
|
srcdir='$srcdir'
|
|
AWK='$AWK'
|
|
test -n "\$AWK" || AWK=awk
|
|
_ACEOF
|
|
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
# The default lists apply if the user does not specify any file.
|
|
ac_need_defaults=:
|
|
while test $# != 0
|
|
do
|
|
case $1 in
|
|
--*=?*)
|
|
ac_option=`expr "X$1" : 'X\([^=]*\)='`
|
|
ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
|
|
ac_shift=:
|
|
;;
|
|
--*=)
|
|
ac_option=`expr "X$1" : 'X\([^=]*\)='`
|
|
ac_optarg=
|
|
ac_shift=:
|
|
;;
|
|
*)
|
|
ac_option=$1
|
|
ac_optarg=$2
|
|
ac_shift=shift
|
|
;;
|
|
esac
|
|
|
|
case $ac_option in
|
|
# Handling of the options.
|
|
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
|
|
ac_cs_recheck=: ;;
|
|
--version | --versio | --versi | --vers | --ver | --ve | --v | -V )
|
|
$as_echo "$ac_cs_version"; exit ;;
|
|
--config | --confi | --conf | --con | --co | --c )
|
|
$as_echo "$ac_cs_config"; exit ;;
|
|
--debug | --debu | --deb | --de | --d | -d )
|
|
debug=: ;;
|
|
--file | --fil | --fi | --f )
|
|
$ac_shift
|
|
case $ac_optarg in
|
|
*\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
|
|
'') as_fn_error $? "missing file argument" ;;
|
|
esac
|
|
as_fn_append CONFIG_FILES " '$ac_optarg'"
|
|
ac_need_defaults=false;;
|
|
--he | --h | --help | --hel | -h )
|
|
$as_echo "$ac_cs_usage"; exit ;;
|
|
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
|
|
| -silent | --silent | --silen | --sile | --sil | --si | --s)
|
|
ac_cs_silent=: ;;
|
|
|
|
# This is an error.
|
|
-*) as_fn_error $? "unrecognized option: \`$1'
|
|
Try \`$0 --help' for more information." ;;
|
|
|
|
*) as_fn_append ac_config_targets " $1"
|
|
ac_need_defaults=false ;;
|
|
|
|
esac
|
|
shift
|
|
done
|
|
|
|
ac_configure_extra_args=
|
|
|
|
if $ac_cs_silent; then
|
|
exec 6>/dev/null
|
|
ac_configure_extra_args="$ac_configure_extra_args --silent"
|
|
fi
|
|
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
if \$ac_cs_recheck; then
|
|
set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
|
|
shift
|
|
\$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
|
|
CONFIG_SHELL='$SHELL'
|
|
export CONFIG_SHELL
|
|
exec "\$@"
|
|
fi
|
|
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
exec 5>>config.log
|
|
{
|
|
echo
|
|
sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
|
|
## Running $as_me. ##
|
|
_ASBOX
|
|
$as_echo "$ac_log"
|
|
} >&5
|
|
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
_ACEOF
|
|
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
|
|
# Handling of arguments.
|
|
for ac_config_target in $ac_config_targets
|
|
do
|
|
case $ac_config_target in
|
|
"$OUTPUT_ROOT/spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in" ;;
|
|
"$OUTPUT_ROOT/bootcycle-spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in" ;;
|
|
"$OUTPUT_ROOT/buildjdk-spec.gmk") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/buildjdk-spec.gmk:$AUTOCONF_DIR/buildjdk-spec.gmk.in" ;;
|
|
"$OUTPUT_ROOT/compare.sh") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in" ;;
|
|
"$OUTPUT_ROOT/Makefile") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" ;;
|
|
|
|
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
|
|
esac
|
|
done
|
|
|
|
|
|
# If the user did not use the arguments to specify the items to instantiate,
|
|
# then the envvar interface is used. Set only those that are not.
|
|
# We use the long form for the default assignment because of an extremely
|
|
# bizarre bug on SunOS 4.1.3.
|
|
if $ac_need_defaults; then
|
|
test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
|
|
fi
|
|
|
|
# Have a temporary directory for convenience. Make it in the build tree
|
|
# simply because there is no reason against having it here, and in addition,
|
|
# creating and moving files from /tmp can sometimes cause problems.
|
|
# Hook for its removal unless debugging.
|
|
# Note that there is a small window in which the directory will not be cleaned:
|
|
# after its creation but before its name has been assigned to `$tmp'.
|
|
$debug ||
|
|
{
|
|
tmp= ac_tmp=
|
|
trap 'exit_status=$?
|
|
: "${ac_tmp:=$tmp}"
|
|
{ test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
|
|
' 0
|
|
trap 'as_fn_exit 1' 1 2 13 15
|
|
}
|
|
# Create a (secure) tmp directory for tmp files.
|
|
|
|
{
|
|
tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
|
|
test -d "$tmp"
|
|
} ||
|
|
{
|
|
tmp=./conf$$-$RANDOM
|
|
(umask 077 && mkdir "$tmp")
|
|
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
|
|
ac_tmp=$tmp
|
|
|
|
# Set up the scripts for CONFIG_FILES section.
|
|
# No need to generate them if there are no CONFIG_FILES.
|
|
# This happens for instance with `./config.status config.h'.
|
|
if test -n "$CONFIG_FILES"; then
|
|
|
|
|
|
ac_cr=`echo X | tr X '\015'`
|
|
# On cygwin, bash can eat \r inside `` if the user requested igncr.
|
|
# But we know of no other shell where ac_cr would be empty at this
|
|
# point, so we can use a bashism as a fallback.
|
|
if test "x$ac_cr" = x; then
|
|
eval ac_cr=\$\'\\r\'
|
|
fi
|
|
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
|
|
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
|
|
ac_cs_awk_cr='\\r'
|
|
else
|
|
ac_cs_awk_cr=$ac_cr
|
|
fi
|
|
|
|
echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
|
|
_ACEOF
|
|
|
|
|
|
{
|
|
echo "cat >conf$$subs.awk <<_ACEOF" &&
|
|
echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
|
|
echo "_ACEOF"
|
|
} >conf$$subs.sh ||
|
|
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
|
|
ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
|
|
ac_delim='%!_!# '
|
|
for ac_last_try in false false false false false :; do
|
|
. ./conf$$subs.sh ||
|
|
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
|
|
|
|
ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
|
|
if test $ac_delim_n = $ac_delim_num; then
|
|
break
|
|
elif $ac_last_try; then
|
|
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
|
|
else
|
|
ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
|
|
fi
|
|
done
|
|
rm -f conf$$subs.sh
|
|
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
|
|
_ACEOF
|
|
sed -n '
|
|
h
|
|
s/^/S["/; s/!.*/"]=/
|
|
p
|
|
g
|
|
s/^[^!]*!//
|
|
:repl
|
|
t repl
|
|
s/'"$ac_delim"'$//
|
|
t delim
|
|
:nl
|
|
h
|
|
s/\(.\{148\}\)..*/\1/
|
|
t more1
|
|
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
|
|
p
|
|
n
|
|
b repl
|
|
:more1
|
|
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
|
|
p
|
|
g
|
|
s/.\{148\}//
|
|
t nl
|
|
:delim
|
|
h
|
|
s/\(.\{148\}\)..*/\1/
|
|
t more2
|
|
s/["\\]/\\&/g; s/^/"/; s/$/"/
|
|
p
|
|
b
|
|
:more2
|
|
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
|
|
p
|
|
g
|
|
s/.\{148\}//
|
|
t delim
|
|
' <conf$$subs.awk | sed '
|
|
/^[^""]/{
|
|
N
|
|
s/\n//
|
|
}
|
|
' >>$CONFIG_STATUS || ac_write_fail=1
|
|
rm -f conf$$subs.awk
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
_ACAWK
|
|
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
|
|
for (key in S) S_is_set[key] = 1
|
|
FS = ""
|
|
|
|
}
|
|
{
|
|
line = $ 0
|
|
nfields = split(line, field, "@")
|
|
substed = 0
|
|
len = length(field[1])
|
|
for (i = 2; i < nfields; i++) {
|
|
key = field[i]
|
|
keylen = length(key)
|
|
if (S_is_set[key]) {
|
|
value = S[key]
|
|
line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
|
|
len += length(value) + length(field[++i])
|
|
substed = 1
|
|
} else
|
|
len += 1 + keylen
|
|
}
|
|
|
|
print line
|
|
}
|
|
|
|
_ACAWK
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
|
|
sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
|
|
else
|
|
cat
|
|
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
|
|
|| as_fn_error $? "could not setup config files machinery" "$LINENO" 5
|
|
_ACEOF
|
|
|
|
# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
|
|
# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
|
|
# trailing colons and then remove the whole line if VPATH becomes empty
|
|
# (actually we leave an empty line to preserve line numbers).
|
|
if test "x$srcdir" = x.; then
|
|
ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{
|
|
h
|
|
s///
|
|
s/^/:/
|
|
s/[ ]*$/:/
|
|
s/:\$(srcdir):/:/g
|
|
s/:\${srcdir}:/:/g
|
|
s/:@srcdir@:/:/g
|
|
s/^:*//
|
|
s/:*$//
|
|
x
|
|
s/\(=[ ]*\).*/\1/
|
|
G
|
|
s/\n//
|
|
s/^[^=]*=[ ]*$//
|
|
}'
|
|
fi
|
|
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
fi # test -n "$CONFIG_FILES"
|
|
|
|
|
|
eval set X " :F $CONFIG_FILES "
|
|
shift
|
|
for ac_tag
|
|
do
|
|
case $ac_tag in
|
|
:[FHLC]) ac_mode=$ac_tag; continue;;
|
|
esac
|
|
case $ac_mode$ac_tag in
|
|
:[FHL]*:*);;
|
|
:L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
|
|
:[FH]-) ac_tag=-:-;;
|
|
:[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
|
|
esac
|
|
ac_save_IFS=$IFS
|
|
IFS=:
|
|
set x $ac_tag
|
|
IFS=$ac_save_IFS
|
|
shift
|
|
ac_file=$1
|
|
shift
|
|
|
|
case $ac_mode in
|
|
:L) ac_source=$1;;
|
|
:[FH])
|
|
ac_file_inputs=
|
|
for ac_f
|
|
do
|
|
case $ac_f in
|
|
-) ac_f="$ac_tmp/stdin";;
|
|
*) # Look for the file first in the build tree, then in the source tree
|
|
# (if the path is not absolute). The absolute path cannot be DOS-style,
|
|
# because $ac_f cannot contain `:'.
|
|
test -f "$ac_f" ||
|
|
case $ac_f in
|
|
[\\/$]*) false;;
|
|
*) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
|
|
esac ||
|
|
as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
|
|
esac
|
|
case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
|
|
as_fn_append ac_file_inputs " '$ac_f'"
|
|
done
|
|
|
|
# Let's still pretend it is `configure' which instantiates (i.e., don't
|
|
# use $as_me), people would be surprised to read:
|
|
# /* config.h. Generated by config.status. */
|
|
configure_input='Generated from '`
|
|
$as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
|
|
`' by configure.'
|
|
if test x"$ac_file" != x-; then
|
|
configure_input="$ac_file. $configure_input"
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
|
|
$as_echo "$as_me: creating $ac_file" >&6;}
|
|
fi
|
|
# Neutralize special characters interpreted by sed in replacement strings.
|
|
case $configure_input in #(
|
|
*\&* | *\|* | *\\* )
|
|
ac_sed_conf_input=`$as_echo "$configure_input" |
|
|
sed 's/[\\\\&|]/\\\\&/g'`;; #(
|
|
*) ac_sed_conf_input=$configure_input;;
|
|
esac
|
|
|
|
case $ac_tag in
|
|
*:-:* | *:-) cat >"$ac_tmp/stdin" \
|
|
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
ac_dir=`$as_dirname -- "$ac_file" ||
|
|
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
|
|
X"$ac_file" : 'X\(//\)[^/]' \| \
|
|
X"$ac_file" : 'X\(//\)$' \| \
|
|
X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
|
|
$as_echo X"$ac_file" |
|
|
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)[^/].*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q'`
|
|
as_dir="$ac_dir"; as_fn_mkdir_p
|
|
ac_builddir=.
|
|
|
|
case "$ac_dir" in
|
|
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
|
|
*)
|
|
ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
|
|
# A ".." for each directory in $ac_dir_suffix.
|
|
ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
|
|
case $ac_top_builddir_sub in
|
|
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
|
|
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
|
|
esac ;;
|
|
esac
|
|
ac_abs_top_builddir=$ac_pwd
|
|
ac_abs_builddir=$ac_pwd$ac_dir_suffix
|
|
# for backward compatibility:
|
|
ac_top_builddir=$ac_top_build_prefix
|
|
|
|
case $srcdir in
|
|
.) # We are building in place.
|
|
ac_srcdir=.
|
|
ac_top_srcdir=$ac_top_builddir_sub
|
|
ac_abs_top_srcdir=$ac_pwd ;;
|
|
[\\/]* | ?:[\\/]* ) # Absolute name.
|
|
ac_srcdir=$srcdir$ac_dir_suffix;
|
|
ac_top_srcdir=$srcdir
|
|
ac_abs_top_srcdir=$srcdir ;;
|
|
*) # Relative name.
|
|
ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
|
|
ac_top_srcdir=$ac_top_build_prefix$srcdir
|
|
ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
|
|
esac
|
|
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
|
|
|
|
|
|
case $ac_mode in
|
|
:F)
|
|
#
|
|
# CONFIG_FILE
|
|
#
|
|
|
|
_ACEOF
|
|
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
# If the template does not know about datarootdir, expand it.
|
|
# FIXME: This hack should be removed a few years after 2.60.
|
|
ac_datarootdir_hack=; ac_datarootdir_seen=
|
|
ac_sed_dataroot='
|
|
/datarootdir/ {
|
|
p
|
|
q
|
|
}
|
|
/@datadir@/p
|
|
/@docdir@/p
|
|
/@infodir@/p
|
|
/@localedir@/p
|
|
/@mandir@/p'
|
|
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
|
|
*datarootdir*) ac_datarootdir_seen=yes;;
|
|
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
|
|
$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
ac_datarootdir_hack='
|
|
s&@datadir@&$datadir&g
|
|
s&@docdir@&$docdir&g
|
|
s&@infodir@&$infodir&g
|
|
s&@localedir@&$localedir&g
|
|
s&@mandir@&$mandir&g
|
|
s&\\\${datarootdir}&$datarootdir&g' ;;
|
|
esac
|
|
_ACEOF
|
|
|
|
# Neutralize VPATH when `$srcdir' = `.'.
|
|
# Shell code in configure.ac might set extrasub.
|
|
# FIXME: do we really want to maintain this feature?
|
|
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
|
ac_sed_extra="$ac_vpsub
|
|
$extrasub
|
|
_ACEOF
|
|
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
|
:t
|
|
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
|
|
s|@configure_input@|$ac_sed_conf_input|;t t
|
|
s&@top_builddir@&$ac_top_builddir_sub&;t t
|
|
s&@top_build_prefix@&$ac_top_build_prefix&;t t
|
|
s&@srcdir@&$ac_srcdir&;t t
|
|
s&@abs_srcdir@&$ac_abs_srcdir&;t t
|
|
s&@top_srcdir@&$ac_top_srcdir&;t t
|
|
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
|
|
s&@builddir@&$ac_builddir&;t t
|
|
s&@abs_builddir@&$ac_abs_builddir&;t t
|
|
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
|
|
$ac_datarootdir_hack
|
|
"
|
|
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
|
|
>$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
|
|
|
|
test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
|
|
{ ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
|
|
{ ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \
|
|
"$ac_tmp/out"`; test -z "$ac_out"; } &&
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
|
|
which seems to be undefined. Please make sure it is defined" >&5
|
|
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
|
|
which seems to be undefined. Please make sure it is defined" >&2;}
|
|
|
|
rm -f "$ac_tmp/stdin"
|
|
case $ac_file in
|
|
-) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
|
|
*) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
|
|
esac \
|
|
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
|
|
;;
|
|
|
|
|
|
|
|
esac
|
|
|
|
done # for ac_tag
|
|
|
|
|
|
as_fn_exit 0
|
|
_ACEOF
|
|
ac_clean_files=$ac_clean_files_save
|
|
|
|
test $ac_write_fail = 0 ||
|
|
as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
|
|
|
|
|
|
# configure is writing to config.log, and then calls config.status.
|
|
# config.status does its own redirection, appending to config.log.
|
|
# Unfortunately, on DOS this fails, as config.log is still kept open
|
|
# by configure, so config.status won't be able to write to it; its
|
|
# output is simply discarded. So we exec the FD to /dev/null,
|
|
# effectively closing config.log, so it can be properly (re)opened and
|
|
# appended to by config.status. When coming back to configure, we
|
|
# need to make the FD available again.
|
|
if test "$no_create" != yes; then
|
|
ac_cs_success=:
|
|
ac_config_status_args=
|
|
test "$silent" = yes &&
|
|
ac_config_status_args="$ac_config_status_args --quiet"
|
|
exec 5>/dev/null
|
|
$SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
|
|
exec 5>>config.log
|
|
# Use ||, not &&, to avoid exiting from the if with $? = 1, which
|
|
# would make configure fail if this is the last instruction.
|
|
$ac_cs_success || as_fn_exit 1
|
|
fi
|
|
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
|
|
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
|
|
$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
|
|
fi
|
|
|
|
|
|
# After AC_OUTPUT, we need to do final work
|
|
|
|
|
|
# Try to move config.log (generated by autoconf) to the configure-support directory.
|
|
if test -e ./config.log; then
|
|
$MV -f ./config.log "$CONFIGURESUPPORT_OUTPUTDIR/config.log" 2> /dev/null
|
|
fi
|
|
|
|
# Rotate our log file (configure.log)
|
|
if test -e "$OUTPUT_ROOT/configure.log.old"; then
|
|
$RM -f "$OUTPUT_ROOT/configure.log.old"
|
|
fi
|
|
if test -e "$OUTPUT_ROOT/configure.log"; then
|
|
$MV -f "$OUTPUT_ROOT/configure.log" "$OUTPUT_ROOT/configure.log.old" 2> /dev/null
|
|
fi
|
|
|
|
# Move configure.log from current directory to the build output root
|
|
if test -e ./configure.log; then
|
|
$MV -f ./configure.log "$OUTPUT_ROOT/configure.log" 2> /dev/null
|
|
fi
|
|
|
|
# Make the compare script executable
|
|
$CHMOD +x $OUTPUT_ROOT/compare.sh
|
|
|
|
|
|
# Finally output some useful information to the user
|
|
|
|
# Finally output some useful information to the user
|
|
|
|
printf "\n"
|
|
printf "====================================================\n"
|
|
if test "x$no_create" != "xyes"; then
|
|
if test "x$IS_RECONFIGURE" != "xyes"; then
|
|
printf "A new configuration has been successfully created in\n%s\n" "$OUTPUT_ROOT"
|
|
else
|
|
printf "The existing configuration has been successfully updated in\n%s\n" "$OUTPUT_ROOT"
|
|
fi
|
|
else
|
|
if test "x$IS_RECONFIGURE" != "xyes"; then
|
|
printf "A configuration has been successfully checked but not created\n"
|
|
else
|
|
printf "The existing configuration has been successfully checked in\n%s\n" "$OUTPUT_ROOT"
|
|
fi
|
|
fi
|
|
if test "x$CONFIGURE_COMMAND_LINE" != x; then
|
|
printf "using configure arguments '$CONFIGURE_COMMAND_LINE'.\n"
|
|
else
|
|
printf "using default settings.\n"
|
|
fi
|
|
|
|
printf "\n"
|
|
printf "Configuration summary:\n"
|
|
printf "* Debug level: $DEBUG_LEVEL\n"
|
|
printf "* HS debug level: $HOTSPOT_DEBUG_LEVEL\n"
|
|
printf "* JDK variant: $JDK_VARIANT\n"
|
|
printf "* JVM variants: $JVM_VARIANTS\n"
|
|
printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n"
|
|
printf "* Version string: $VERSION_STRING ($VERSION_SHORT)\n"
|
|
|
|
printf "\n"
|
|
printf "Tools summary:\n"
|
|
if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
|
|
printf "* Environment: $WINDOWS_ENV_VENDOR version $WINDOWS_ENV_VERSION (root at $WINDOWS_ENV_ROOT_PATH)\n"
|
|
fi
|
|
printf "* Boot JDK: $BOOT_JDK_VERSION (at $BOOT_JDK)\n"
|
|
if test "x$TOOLCHAIN_VERSION" != "x"; then
|
|
print_version=" $TOOLCHAIN_VERSION"
|
|
fi
|
|
printf "* Toolchain: $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION$print_version)\n"
|
|
printf "* C Compiler: Version $CC_VERSION_NUMBER (at $CC)\n"
|
|
printf "* C++ Compiler: Version $CXX_VERSION_NUMBER (at $CXX)\n"
|
|
|
|
printf "\n"
|
|
printf "Build performance summary:\n"
|
|
printf "* Cores to use: $JOBS\n"
|
|
printf "* Memory limit: $MEMORY_SIZE MB\n"
|
|
if test "x$CCACHE_STATUS" != "x"; then
|
|
printf "* ccache status: $CCACHE_STATUS\n"
|
|
fi
|
|
printf "\n"
|
|
|
|
if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xtrue"; then
|
|
printf "NOTE: You have requested to build more than one version of the JVM, which\n"
|
|
printf "will result in longer build times.\n"
|
|
printf "\n"
|
|
fi
|
|
|
|
if test "x$FOUND_ALT_VARIABLES" != "x"; then
|
|
printf "WARNING: You have old-style ALT_ environment variables set.\n"
|
|
printf "These are not respected, and will be ignored. It is recommended\n"
|
|
printf "that you clean your environment. The following variables are set:\n"
|
|
printf "$FOUND_ALT_VARIABLES\n"
|
|
printf "\n"
|
|
fi
|
|
|
|
if test "x$OUTPUT_DIR_IS_LOCAL" != "xyes"; then
|
|
printf "WARNING: Your build output directory is not on a local disk.\n"
|
|
printf "This will severely degrade build performance!\n"
|
|
printf "It is recommended that you create an output directory on a local disk,\n"
|
|
printf "and run the configure script again from that directory.\n"
|
|
printf "\n"
|
|
fi
|
|
|
|
if test "x$IS_RECONFIGURE" = "xyes" && test "x$no_create" != "xyes"; then
|
|
printf "WARNING: The result of this configuration has overridden an older\n"
|
|
printf "configuration. You *should* run 'make clean' to make sure you get a\n"
|
|
printf "proper build. Failure to do so might result in strange build problems.\n"
|
|
printf "\n"
|
|
fi
|
|
|
|
if test "x$IS_RECONFIGURE" != "xyes" && test "x$no_create" = "xyes"; then
|
|
printf "WARNING: The result of this configuration was not saved.\n"
|
|
printf "You should run without '--no-create | -n' to create the configuration.\n"
|
|
printf "\n"
|
|
fi
|
|
|
|
|
|
|
|
# Locate config.log.
|
|
if test -e "$CONFIGURESUPPORT_OUTPUTDIR/config.log"; then
|
|
CONFIG_LOG_PATH="$CONFIGURESUPPORT_OUTPUTDIR"
|
|
elif test -e "./config.log"; then
|
|
CONFIG_LOG_PATH="."
|
|
fi
|
|
|
|
if test -e "$CONFIG_LOG_PATH/config.log"; then
|
|
$GREP '^configure:.*: WARNING:' "$CONFIG_LOG_PATH/config.log" > /dev/null 2>&1
|
|
if test $? -eq 0; then
|
|
printf "The following warnings were produced. Repeated here for convenience:\n"
|
|
# We must quote sed expression (using []) to stop m4 from eating the [].
|
|
$GREP '^configure:.*: WARNING:' "$CONFIG_LOG_PATH/config.log" | $SED -e 's/^configure:[0-9]*: //'
|
|
printf "\n"
|
|
fi
|
|
fi
|
|
|