< prev index next >
common/autoconf/generated-configure.sh
Print this page
*** 3462,3471 ****
--- 3462,3475 ----
# Setup basic configuration paths, and platform-specific stuff related to PATHs.
+ # Evaluates platform specific overrides for devkit variables.
+ # $1: Name of variable
+
+
#%%% Simple tools %%%
*** 4361,4371 ****
# 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=1429271657
###############################################################################
#
# Initialization / Boot-strapping
#
--- 4365,4375 ----
# 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=1429725895
###############################################################################
#
# Initialization / Boot-strapping
#
*** 14180,14190 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 14184,14194 ----
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
*** 14306,14316 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 14310,14320 ----
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
*** 14876,14886 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 14880,14890 ----
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
*** 14963,14978 ****
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
- # This potentially sets the following:
- # DEVKIT_NAME: A descriptive name of the devkit
- # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path
- # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path
- # DEVKIT_SYSROOT: Corresponds to --with-sysroot
. $DEVKIT_ROOT/devkit.info
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
--- 14967,15033 ----
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
*** 14981,15001 ****
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$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
- 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
--- 15036,15054 ----
*** 15286,15296 ****
# 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/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
--- 15339,15353 ----
# 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/confdefs.h//g' \
! -e 's/fixpath.exe//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
*** 15354,15364 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 15411,15421 ----
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
*** 15669,15679 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 15726,15736 ----
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
*** 16056,16066 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 16113,16123 ----
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
*** 16440,16450 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 16497,16507 ----
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
*** 16829,16839 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 16886,16896 ----
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
*** 17212,17222 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 17269,17279 ----
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
*** 20277,20287 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 20334,20344 ----
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
*** 20606,20616 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 20663,20673 ----
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
*** 20797,20807 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 20854,20864 ----
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
*** 20981,20991 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 21038,21048 ----
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
*** 21164,21174 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 21221,21231 ----
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
*** 21347,21357 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 21404,21414 ----
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
*** 21521,21531 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 21578,21588 ----
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
*** 21670,21680 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 21727,21737 ----
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
*** 21840,21850 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 21897,21907 ----
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
*** 22165,22175 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 22222,22232 ----
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
*** 22377,22387 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 22434,22444 ----
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
*** 22554,22564 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 22611,22621 ----
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
*** 22759,22769 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 22816,22826 ----
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
*** 22936,22946 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 22993,23003 ----
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
*** 23141,23151 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 23198,23208 ----
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
*** 23318,23328 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 23375,23385 ----
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
*** 23523,23533 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 23580,23590 ----
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
*** 23700,23710 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 23757,23767 ----
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
*** 23892,23902 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 23949,23959 ----
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
*** 24067,24077 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 24124,24134 ----
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
*** 24260,24270 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 24317,24327 ----
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
*** 24435,24445 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 24492,24502 ----
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
*** 24627,24637 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 24684,24694 ----
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
*** 24802,24812 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 24859,24869 ----
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
*** 24995,25005 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 25052,25062 ----
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
*** 25170,25180 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 25227,25237 ----
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
*** 25344,25354 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 25401,25411 ----
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
*** 26724,26738 ****
# Store the CFLAGS etc passed to the configure script.
ORG_CFLAGS="$CFLAGS"
ORG_CXXFLAGS="$CXXFLAGS"
# 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
--- 26781,26799 ----
# 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
*** 26806,26815 ****
--- 26867,26926 ----
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;}
*** 27378,27387 ****
--- 27489,27500 ----
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
*** 27479,27489 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 27592,27602 ----
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
*** 27711,27726 ****
$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
--- 27824,27845 ----
$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
*** 27747,27762 ****
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
# 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; 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
--- 27866,27883 ----
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
*** 27837,27847 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 27958,27968 ----
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
*** 27987,27997 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 28108,28118 ----
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
*** 28106,28118 ****
# The microsoft toolchain also requires INCLUDE and LIB to be set.
export INCLUDE="$VS_INCLUDE"
export LIB="$VS_LIB"
fi
- # autoconf magic only relies on PATH, so update it if tools dir is specified
- OLD_PATH="$PATH"
-
# For solaris we really need solaris tools, and not the GNU equivalent.
# The build tools on Solaris reside in /usr/ccs (C Compilation System),
# so add that to path before starting to probe.
# FIXME: This was originally only done for AS,NM,GNM,STRIP,MCS,OBJCOPY,OBJDUMP.
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
--- 28227,28236 ----
*** 28447,28457 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 28565,28575 ----
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
*** 28908,28918 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 29026,29036 ----
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
*** 30195,30205 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 30313,30323 ----
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
*** 30656,30666 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 30774,30784 ----
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
*** 31522,31532 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 31640,31650 ----
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
*** 31941,31951 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 32059,32069 ----
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
*** 32289,32299 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 32407,32417 ----
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
*** 32788,32798 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 32906,32916 ----
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
*** 33420,33430 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 33538,33548 ----
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
*** 33895,33905 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 34013,34023 ----
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
*** 34238,34248 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 34356,34366 ----
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
*** 34579,34589 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 34697,34707 ----
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
*** 34902,34912 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 35020,35030 ----
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
*** 35421,35431 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 35539,35549 ----
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
*** 35893,35903 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 36011,36021 ----
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
*** 36365,36375 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 36483,36493 ----
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
*** 36838,36848 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 36956,36966 ----
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
*** 37422,37432 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 37540,37550 ----
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
*** 38004,38014 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 38122,38132 ----
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
*** 38595,38605 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 38713,38723 ----
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
*** 39183,39193 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 39301,39311 ----
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
*** 39679,39689 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 39797,39807 ----
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
*** 40151,40161 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 40269,40279 ----
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
*** 40623,40633 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 40741,40751 ----
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
*** 41174,41184 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 41292,41302 ----
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
*** 44728,44738 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 44846,44856 ----
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
*** 44854,44864 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 44972,44982 ----
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
*** 45089,45099 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 45207,45217 ----
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
*** 45215,45225 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 45333,45343 ----
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
*** 45711,45721 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 45829,45839 ----
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
*** 45837,45847 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 45955,45965 ----
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
*** 46047,46057 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 46165,46175 ----
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
*** 46173,46183 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 46291,46301 ----
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
*** 46374,46384 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 46492,46502 ----
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
*** 46500,46510 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 46618,46628 ----
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
*** 46701,46711 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 46819,46829 ----
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
*** 46827,46837 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 46945,46955 ----
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
*** 47029,47039 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 47147,47157 ----
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
*** 47155,47165 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 47273,47283 ----
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
*** 47358,47368 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 47476,47486 ----
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
*** 47484,47494 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 47602,47612 ----
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
*** 47683,47693 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 47801,47811 ----
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
*** 47809,47819 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 47927,47937 ----
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
*** 48008,48018 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 48126,48136 ----
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
*** 48134,48144 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 48252,48262 ----
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
*** 48316,48326 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 48434,48444 ----
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
*** 48450,48460 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 48568,48578 ----
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
*** 49965,49975 ****
if test "x$with_msvcr_dll" != x; then
# If given explicitely by user, do not probe. If not present, fail directly.
! DLL_NAME="$DLL_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;}
--- 50083,50093 ----
if test "x$with_msvcr_dll" != x; then
# If given explicitely 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;}
*** 49995,50076 ****
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"
! { $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
- else
- VAR_NAME="MSVCR_DLL"
- 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"
{ $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
--- 50113,50248 ----
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
+
+ MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
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
*** 50079,50098 ****
{ $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
--- 50251,50269 ----
{ $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
*** 50116,50250 ****
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"
- { $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"
- { $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"
{ $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
--- 50287,50422 ----
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
+
+ MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
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
*** 50253,50286 ****
{ $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
--- 50425,50467 ----
{ $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
*** 50304,50346 ****
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"
- { $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
# Only process if variable expands to non-empty
! if test "x$MSVCR_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="$MSVCR_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
--- 50485,50503 ----
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
*** 50348,50360 ****
#
# 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 MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
! $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
! as_fn_error $? "Cannot locate the the path of MSVCR_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.
--- 50505,50517 ----
#
# 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.
*** 50370,50380 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 50527,50537 ----
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
*** 50388,50405 ****
fi
fi
if test "x$path" != "x$new_path"; then
! MSVCR_DLL="$new_path"
! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5
! $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;}
fi
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
! path="$MSVCR_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`
--- 50545,50562 ----
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`
*** 50426,50482 ****
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
! MSVCR_DLL="$new_path"
! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5
! $as_echo "$as_me: Rewriting MSVCR_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="$MSVCR_DLL"
has_space=`$ECHO "$path" | $GREP " "`
if test "x$has_space" != x; then
! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
! $as_echo "$as_me: The path of MSVCR_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 MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
fi
! MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`"
fi
fi
! MSVCR_DLL=$MSVCR_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 explicitely by user, do not probe. If not present, fail directly.
DLL_NAME="$DLL_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
--- 50583,50642 ----
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
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
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
*** 50500,50534 ****
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"
- { $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
! else
! VAR_NAME="MSVCP_DLL"
! 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"
--- 50660,51754 ----
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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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 explicitely 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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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"
*** 50572,50581 ****
--- 51792,51927 ----
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
+
+ MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+ 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
*** 50621,50630 ****
--- 51967,52102 ----
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
+
+ MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+ 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
*** 50680,50689 ****
--- 52152,52287 ----
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
+
+ MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+ 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
*** 50746,50755 ****
--- 52344,52479 ----
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
+
+ MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+ 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
*** 50809,50851 ****
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"
- { $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
# Only process if variable expands to non-empty
! if test "x$MSVCP_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="$MSVCP_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
--- 52533,52551 ----
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
*** 50853,50865 ****
#
# 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 MSVCP_DLL, which resolves as \"$path\", is invalid." >&5
! $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;}
! as_fn_error $? "Cannot locate the the path of MSVCP_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.
--- 52553,52565 ----
#
# 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.
*** 50875,50885 ****
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-stile (cygpath)
input_path=`$CYGPATH -u "$shortmode_path"`
new_path="$input_path"
fi
fi
--- 52575,52585 ----
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
*** 50893,50910 ****
fi
fi
if test "x$path" != "x$new_path"; then
! MSVCP_DLL="$new_path"
! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5
! $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;}
fi
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
! path="$MSVCP_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`
--- 52593,52610 ----
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`
*** 50931,50972 ****
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
! MSVCP_DLL="$new_path"
! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5
! $as_echo "$as_me: Rewriting MSVCP_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="$MSVCP_DLL"
has_space=`$ECHO "$path" | $GREP " "`
if test "x$has_space" != x; then
! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5
! $as_echo "$as_me: The path of MSVCP_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 MSVCP_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
fi
! MSVCP_DLL="`cd "$path"; $THEPWDCMD -L`"
fi
fi
! MSVCP_DLL=$MSVCP_DLL
fi
fi
# Check whether --with-dxsdk was given.
--- 52631,52694 ----
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
!
! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
! 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
# Check whether --with-dxsdk was given.
< prev index next >