< prev index next >

common/autoconf/generated-configure.sh

Print this page

        

*** 3402,3411 **** --- 3402,3415 ---- # Setup basic configuration paths, and platform-specific stuff related to PATHs. + # Evaluates platform specific overrides for devkit variables. + # $1: Name of variable + +
*** 4299,4309 **** # 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=1526507291 ############################################################################### # # Initialization / Boot-strapping # --- 4303,4313 ---- # 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=1526679992 ############################################################################### # # Initialization / Boot-strapping #
*** 14115,14125 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 14119,14129 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 14237,14247 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 14241,14251 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 14724,14734 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 14728,14738 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 14810,14825 **** 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 --- 14814,14880 ---- 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
*** 14828,14848 **** 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 --- 14883,14901 ----
*** 15026,15036 **** # 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 --- 15079,15093 ---- # 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
*** 15091,15101 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 15148,15158 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 15394,15404 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 15451,15461 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 15767,15777 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 15824,15834 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 16137,16147 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 16194,16204 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 16512,16522 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 16569,16579 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 16881,16891 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 16938,16948 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 19883,19893 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 19940,19950 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 20215,20225 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 20272,20282 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 20361,20371 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 20418,20428 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 20533,20543 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 20590,20600 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 20721,20731 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 20778,20788 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 21049,21059 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 21106,21116 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 21264,21274 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 21321,21331 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 21444,21454 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 21501,21511 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 21652,21662 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 21709,21719 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 21832,21842 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 21889,21899 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 22040,22050 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 22097,22107 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 22220,22230 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 22277,22287 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 22428,22438 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 22485,22495 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 22608,22618 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 22665,22675 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 22803,22813 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 22860,22870 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 22981,22991 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 23038,23048 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 23177,23187 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 23234,23244 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 23355,23365 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 23412,23422 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 23550,23560 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 23607,23617 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 23728,23738 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 23785,23795 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 23924,23934 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 23981,23991 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 24102,24112 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 24159,24169 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 24279,24289 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 24336,24346 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 25209,25223 **** # Store the CFLAGS etal passed to the configure script. ORG_CFLAGS="$CFLAGS" ORG_CXXFLAGS="$CXXFLAGS" ORG_OBJCFLAGS="$OBJCFLAGS" # 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 --- 25266,25284 ---- # Store the CFLAGS etal passed to the configure script. ORG_CFLAGS="$CFLAGS" ORG_CXXFLAGS="$CXXFLAGS" ORG_OBJCFLAGS="$OBJCFLAGS" + # 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
*** 25291,25300 **** --- 25352,25411 ---- 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;}
*** 25863,25872 **** --- 25974,25985 ---- 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. if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
*** 25961,25971 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 26074,26084 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 26192,26207 **** $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 \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VS_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 --- 26305,26326 ---- $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 \" >> set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VS_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
*** 26228,26243 **** 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 --- 26347,26364 ---- 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
*** 26283,26295 **** # 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" - # Before we locate the compilers, we need to sanitize the Xcode build environment if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then # determine path to Xcode developer directory # can be empty in which case all the tools will rely on a sane Xcode 4 installation SET_DEVELOPER_DIR= --- 26404,26413 ----
*** 26748,26758 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 26866,26876 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 27205,27215 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 27323,27333 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 28490,28500 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 28608,28618 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 28947,28957 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 29065,29075 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 29837,29847 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 29955,29965 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 30252,30262 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 30370,30380 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 30596,30606 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 30714,30724 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 31091,31101 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 31209,31219 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 31719,31729 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 31837,31847 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 32255,32265 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 32373,32383 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 32723,32733 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 32841,32851 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 33064,33074 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 33182,33192 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 33401,33411 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 33519,33529 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 33720,33730 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 33838,33848 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 34235,34245 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 34353,34363 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 34703,34713 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 34821,34831 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 35171,35181 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 35289,35299 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 35640,35650 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 35758,35768 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 36220,36230 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 36338,36348 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 36841,36851 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 36959,36969 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 37428,37438 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 37546,37556 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 38012,38022 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 38130,38140 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 38505,38515 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 38623,38633 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 38973,38983 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 39091,39101 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 39441,39451 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 39559,39569 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 39821,39831 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 39939,39949 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 43358,43368 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 43476,43486 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 43480,43490 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 43598,43608 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 43685,43695 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 43803,43813 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 43807,43817 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 43925,43935 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 44273,44283 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 44391,44401 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 44395,44405 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 44513,44523 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 44575,44585 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 44693,44703 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 44697,44707 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 44815,44825 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 44868,44878 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 44986,44996 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 44990,45000 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45108,45118 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 45161,45171 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45279,45289 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 45283,45293 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45401,45411 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 45455,45465 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45573,45583 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 45577,45587 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45695,45705 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 45750,45760 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45868,45878 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 45872,45882 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 45990,46000 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 46041,46051 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 46159,46169 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 46163,46173 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 46281,46291 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 46332,46342 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 46450,46460 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 46454,46464 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 46572,46582 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 46632,46642 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 46750,46760 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 46762,46772 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 46880,46890 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 48013,48023 **** 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;} --- 48131,48141 ---- 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;}
*** 48043,48124 **** 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 --- 48161,48292 ---- 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" ! ! 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 posix 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 ! { $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
*** 48127,48146 **** { $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 --- 48295,48313 ---- { $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
*** 48164,48298 **** 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 --- 48331,48462 ---- 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" ! 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 posix 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 ! { $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
*** 48301,48334 **** { $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 --- 48465,48507 ---- { $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
*** 48352,48391 **** 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 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 --- 48525,48540 ---- 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" 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
*** 48393,48405 **** # # 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. --- 48542,48554 ---- # # 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.
*** 48415,48425 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 48564,48574 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 48433,48450 **** 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` --- 48582,48599 ---- 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`
*** 48471,48526 **** 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 posix 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 ! 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 --- 48620,48678 ---- 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 posix 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 ! { $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
*** 48544,48575 **** 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" --- 48696,49763 ---- 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" ! 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 posix 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 ! ! { $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" ! ! 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 posix 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 ! ! { $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" ! ! 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 posix 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 ! ! { $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" ! ! 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 posix 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 ! ! { $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" ! ! 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 posix 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 ! ! { $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" ! ! 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 posix 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 ! ! { $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"
*** 48616,48625 **** --- 49804,49935 ---- 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" + + 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 posix 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 + { $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
*** 48665,48674 **** --- 49975,50106 ---- 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" + + 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 posix 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 + { $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
*** 48724,48733 **** --- 50156,50287 ---- 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" + + 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 posix 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 + { $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
*** 48790,48799 **** --- 50344,50475 ---- 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" + + 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 posix 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 + { $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
*** 48853,48892 **** 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 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 --- 50529,50544 ---- 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" 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
*** 48894,48906 **** # # 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. --- 50546,50558 ---- # # 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.
*** 48916,48926 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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 --- 50568,50578 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # 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
*** 48934,48951 **** 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` --- 50586,50603 ---- 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`
*** 48972,49012 **** 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 posix 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 ! MSVCP_DLL=$MSVCP_DLL fi fi # Check whether --with-dxsdk was given. --- 50624,50686 ---- 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 posix 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 ! { $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 >