< prev index next >

common/autoconf/generated-configure.sh

Print this page

        

*** 3462,3471 **** --- 3462,3475 ---- # Setup basic configuration paths, and platform-specific stuff related to PATHs. + # Evaluates platform specific overrides for devkit variables. + # $1: Name of variable + + #%%% Simple tools %%%
*** 4361,4371 **** # definitions. It is replaced with custom functionality when building # custom sources. #CUSTOM_AUTOCONF_INCLUDE # Do not change or remove the following line, it is needed for consistency checks: ! DATE_WHEN_GENERATED=1429271657 ############################################################################### # # Initialization / Boot-strapping # --- 4365,4375 ---- # definitions. It is replaced with custom functionality when building # custom sources. #CUSTOM_AUTOCONF_INCLUDE # Do not change or remove the following line, it is needed for consistency checks: ! DATE_WHEN_GENERATED=1429725895 ############################################################################### # # Initialization / Boot-strapping #
*** 14180,14190 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 14184,14194 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 14306,14316 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 14310,14320 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 14876,14886 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 14880,14890 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 14963,14978 **** fi DEVKIT_ROOT="$with_devkit" # Check for a meta data info file in the root of the devkit if test -f "$DEVKIT_ROOT/devkit.info"; then - # This potentially sets the following: - # DEVKIT_NAME: A descriptive name of the devkit - # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path - # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path - # DEVKIT_SYSROOT: Corresponds to --with-sysroot . $DEVKIT_ROOT/devkit.info fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5 $as_echo_n "checking for devkit... " >&6; } if test "x$DEVKIT_NAME" != x; then --- 14967,15033 ---- fi DEVKIT_ROOT="$with_devkit" # Check for a meta data info file in the root of the devkit if test -f "$DEVKIT_ROOT/devkit.info"; then . $DEVKIT_ROOT/devkit.info + # This potentially sets the following: + # A descriptive name of the devkit + + if test "x$DEVKIT_NAME" = x; then + eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}" + fi + + # Corresponds to --with-extra-path + + if test "x$DEVKIT_EXTRA_PATH" = x; then + eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}" + fi + + # Corresponds to --with-toolchain-path + + if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then + eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}" + fi + + # Corresponds to --with-sysroot + + if test "x$DEVKIT_SYSROOT" = x; then + eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}" + fi + + + # Identifies the Visual Studio version in the devkit + + if test "x$DEVKIT_VS_VERSION" = x; then + eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}" + fi + + # The Visual Studio include environment variable + + if test "x$DEVKIT_VS_INCLUDE" = x; then + eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}" + fi + + # The Visual Studio lib environment variable + + if test "x$DEVKIT_VS_LIB" = x; then + eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}" + fi + + # Corresponds to --with-msvcr-dll + + if test "x$DEVKIT_MSVCR_DLL" = x; then + eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}" + fi + + # Corresponds to --with-msvcp-dll + + if test "x$DEVKIT_MSVCP_DLL" = x; then + eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}" + fi + fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5 $as_echo_n "checking for devkit... " >&6; } if test "x$DEVKIT_NAME" != x; then
*** 14981,15001 **** else { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5 $as_echo "$DEVKIT_ROOT" >&6; } fi - if test "x$DEVKIT_EXTRA_PATH" != x; then if test "x$DEVKIT_EXTRA_PATH" != x; then if test "x$EXTRA_PATH" = x; then EXTRA_PATH="$DEVKIT_EXTRA_PATH" else EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH" fi fi - fi # Fallback default of just /bin if DEVKIT_PATH is not defined if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin" fi --- 15036,15054 ----
*** 15286,15296 **** # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for # other files files_present=`$LS $OUTPUT_ROOT` # Configure has already touched config.log and confdefs.h in the current dir when this check # is performed. ! filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \ | $TR -d '\n'` if test "x$filtered_files" != x; then { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5 $as_echo "$as_me: Current directory is $CURDIR." >&6;} { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5 --- 15339,15353 ---- # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for # other files files_present=`$LS $OUTPUT_ROOT` # Configure has already touched config.log and confdefs.h in the current dir when this check # is performed. ! filtered_files=`$ECHO "$files_present" \ ! | $SED -e 's/config.log//g' \ ! -e 's/confdefs.h//g' \ ! -e 's/fixpath.exe//g' \ ! -e 's/ //g' \ | $TR -d '\n'` if test "x$filtered_files" != x; then { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5 $as_echo "$as_me: Current directory is $CURDIR." >&6;} { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
*** 15354,15364 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 15411,15421 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 15669,15679 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 15726,15736 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 16056,16066 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 16113,16123 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 16440,16450 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 16497,16507 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 16829,16839 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 16886,16896 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 17212,17222 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 17269,17279 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 20277,20287 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 20334,20344 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 20606,20616 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 20663,20673 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 20797,20807 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 20854,20864 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 20981,20991 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 21038,21048 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 21164,21174 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 21221,21231 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 21347,21357 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 21404,21414 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 21521,21531 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 21578,21588 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 21670,21680 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 21727,21737 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 21840,21850 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 21897,21907 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 22165,22175 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 22222,22232 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 22377,22387 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 22434,22444 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 22554,22564 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 22611,22621 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 22759,22769 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 22816,22826 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 22936,22946 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 22993,23003 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 23141,23151 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 23198,23208 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 23318,23328 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 23375,23385 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 23523,23533 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 23580,23590 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 23700,23710 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 23757,23767 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 23892,23902 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 23949,23959 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 24067,24077 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 24124,24134 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 24260,24270 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 24317,24327 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 24435,24445 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 24492,24502 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 24627,24637 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 24684,24694 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 24802,24812 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 24859,24869 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 24995,25005 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 25052,25062 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 25170,25180 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 25227,25237 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 25344,25354 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 25401,25411 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 26724,26738 **** # Store the CFLAGS etc passed to the configure script. ORG_CFLAGS="$CFLAGS" ORG_CXXFLAGS="$CXXFLAGS" # On Windows, we need to detect the visual studio installation first. # This will change the PATH, but we need to keep that new PATH even # after toolchain detection is done, since the compiler (on x86) uses # it for DLL resolution in runtime. ! if test "x$OPENJDK_BUILD_OS" = "xwindows" && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then # Store path to cygwin link.exe to help excluding it when searching for # VS linker. This must be done before changing the PATH when looking for VS. # Extract the first word of "link", so it can be a program name with args. set dummy link; ac_word=$2 --- 26781,26799 ---- # Store the CFLAGS etc passed to the configure script. ORG_CFLAGS="$CFLAGS" ORG_CXXFLAGS="$CXXFLAGS" + # autoconf magic only relies on PATH, so update it if tools dir is specified + OLD_PATH="$PATH" + # On Windows, we need to detect the visual studio installation first. # This will change the PATH, but we need to keep that new PATH even # after toolchain detection is done, since the compiler (on x86) uses # it for DLL resolution in runtime. ! if test "x$OPENJDK_BUILD_OS" = "xwindows" \ ! && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then # Store path to cygwin link.exe to help excluding it when searching for # VS linker. This must be done before changing the PATH when looking for VS. # Extract the first word of "link", so it can be a program name with args. set dummy link; ac_word=$2
*** 26806,26815 **** --- 26867,26926 ---- eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version} $PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION" done exit 0 + elif test "x$DEVKIT_VS_VERSION" != x; then + VS_VERSION=$DEVKIT_VS_VERSION + TOOLCHAIN_VERSION=$VS_VERSION + eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}" + eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}" + eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}" + eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}" + eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}" + VS_PATH="$TOOLCHAIN_PATH:$PATH" + + # Convert DEVKIT_VS_INCLUDE into windows style VS_INCLUDE so that it + # can still be exported as INCLUDE for compiler invocations without + # SYSROOT_CFLAGS + OLDIFS="$IFS" + IFS=";" + for i in $DEVKIT_VS_INCLUDE; do + ipath=$i + + unix_path="$ipath" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + windows_path=`$CYGPATH -m "$unix_path"` + ipath="$windows_path" + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + windows_path=`cmd //c echo $unix_path` + ipath="$windows_path" + fi + + VS_INCLUDE="$VS_INCLUDE;$ipath" + done + # Convert DEVKIT_VS_LIB into VS_LIB so that it can still be exported + # as LIB for compiler invocations without SYSROOT_LDFLAGS + for i in $DEVKIT_VS_LIB; do + libpath=$i + + unix_path="$libpath" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + windows_path=`$CYGPATH -m "$unix_path"` + libpath="$windows_path" + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + windows_path=`cmd //c echo $unix_path` + libpath="$windows_path" + fi + + VS_LIB="$VS_LIB;$libpath" + done + IFS="$OLDIFS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5 + $as_echo "$as_me: Found devkit $VS_DESCRIPTION" >&6;} + elif test "x$with_toolchain_version" != x; then # User override; check that it is valid if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5 $as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
*** 27378,27387 **** --- 27489,27500 ---- break fi done + # If we have a devkit, skip all of the below. + if test "x$DEVKIT_VS_VERSION" = x; then if test "x$VS_ENV_CMD" != x; then # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file. # Only process if variable expands to non-empty
*** 27479,27489 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 27592,27602 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 27711,27726 **** $ECHO "call $WINPATH_VS_ENV_CMD $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE # These will end up something like: # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh # The trailing space for everyone except PATH is no typo, but is needed due # to trailing \ in the Windows paths. These will be stripped later. ! $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE\;$include \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB\;$lib \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE # Now execute the newly created bat file. # The | cat is to stop SetEnv.Cmd to mess with system colors on msys. # Change directory so we don't need to mess with Windows paths in redirects. cd $VS_ENV_TMP_DIR --- 27824,27845 ---- $ECHO "call $WINPATH_VS_ENV_CMD $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE # These will end up something like: # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh # The trailing space for everyone except PATH is no typo, but is needed due # to trailing \ in the Windows paths. These will be stripped later. ! $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE\;$include \" >> set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB\;$lib \" >> set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE ! $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' \ ! >> $EXTRACT_VC_ENV_BAT_FILE # Now execute the newly created bat file. # The | cat is to stop SetEnv.Cmd to mess with system colors on msys. # Change directory so we don't need to mess with Windows paths in redirects. cd $VS_ENV_TMP_DIR
*** 27747,27762 **** else # We did not find a vsvars bat file, let's hope we are run from a VS command prompt. { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5 $as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;} fi # At this point, we should have correct variables in the environment, or we can't continue. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5 $as_echo_n "checking for Visual Studio variables... " >&6; } ! if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x || test "x$WINDOWSSDKDIR" != x; then if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5 $as_echo "present but broken" >&6; } as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5 else --- 27866,27883 ---- else # We did not find a vsvars bat file, let's hope we are run from a VS command prompt. { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5 $as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;} fi + fi # At this point, we should have correct variables in the environment, or we can't continue. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5 $as_echo_n "checking for Visual Studio variables... " >&6; } ! if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \ ! || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5 $as_echo "present but broken" >&6; } as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5 else
*** 27837,27847 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 27958,27968 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 27987,27997 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 28108,28118 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 28106,28118 **** # The microsoft toolchain also requires INCLUDE and LIB to be set. export INCLUDE="$VS_INCLUDE" export LIB="$VS_LIB" fi - # autoconf magic only relies on PATH, so update it if tools dir is specified - OLD_PATH="$PATH" - # For solaris we really need solaris tools, and not the GNU equivalent. # The build tools on Solaris reside in /usr/ccs (C Compilation System), # so add that to path before starting to probe. # FIXME: This was originally only done for AS,NM,GNM,STRIP,MCS,OBJCOPY,OBJDUMP. if test "x$OPENJDK_BUILD_OS" = xsolaris; then --- 28227,28236 ----
*** 28447,28457 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 28565,28575 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 28908,28918 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 29026,29036 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 30195,30205 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 30313,30323 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 30656,30666 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 30774,30784 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 31522,31532 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 31640,31650 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 31941,31951 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 32059,32069 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 32289,32299 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 32407,32417 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 32788,32798 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 32906,32916 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 33420,33430 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 33538,33548 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 33895,33905 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 34013,34023 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 34238,34248 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 34356,34366 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 34579,34589 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 34697,34707 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 34902,34912 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 35020,35030 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 35421,35431 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 35539,35549 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 35893,35903 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 36011,36021 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 36365,36375 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 36483,36493 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 36838,36848 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 36956,36966 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 37422,37432 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 37540,37550 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 38004,38014 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 38122,38132 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 38595,38605 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 38713,38723 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 39183,39193 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 39301,39311 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 39679,39689 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 39797,39807 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 40151,40161 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 40269,40279 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 40623,40633 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 40741,40751 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 41174,41184 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 41292,41302 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 44728,44738 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 44846,44856 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 44854,44864 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 44972,44982 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 45089,45099 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 45207,45217 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 45215,45225 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 45333,45343 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 45711,45721 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 45829,45839 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 45837,45847 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 45955,45965 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 46047,46057 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 46165,46175 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 46173,46183 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 46291,46301 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 46374,46384 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 46492,46502 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 46500,46510 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 46618,46628 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 46701,46711 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 46819,46829 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 46827,46837 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 46945,46955 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 47029,47039 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 47147,47157 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 47155,47165 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 47273,47283 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 47358,47368 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 47476,47486 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 47484,47494 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 47602,47612 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 47683,47693 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 47801,47811 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 47809,47819 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 47927,47937 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 48008,48018 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 48126,48136 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 48134,48144 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 48252,48262 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 48316,48326 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 48434,48444 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 48450,48460 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 48568,48578 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 49965,49975 **** if test "x$with_msvcr_dll" != x; then # If given explicitely by user, do not probe. If not present, fail directly. ! DLL_NAME="$DLL_NAME" POSSIBLE_MSVC_DLL="$with_msvcr_dll" METHOD="--with-msvcr-dll" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} --- 50083,50093 ---- if test "x$with_msvcr_dll" != x; then # If given explicitely by user, do not probe. If not present, fail directly. ! DLL_NAME="$MSVCR_NAME" POSSIBLE_MSVC_DLL="$with_msvcr_dll" METHOD="--with-msvcr-dll" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
*** 49995,50076 **** fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi ! if test "x$MSVC_DLL" = x; then ! as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5 fi - else - VAR_NAME="MSVCR_DLL" - DLL_NAME="${MSVCR_NAME}" - MSVC_DLL= ! if test "x$MSVC_DLL" = x; then ! # Probe: Using well-known location from Visual Studio 10.0 ! if test "x$VCINSTALLDIR" != x; then ! CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR" ! windows_path="$CYGWIN_VC_INSTALL_DIR" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then unix_path=`$CYGPATH -u "$windows_path"` ! CYGWIN_VC_INSTALL_DIR="$unix_path" elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! CYGWIN_VC_INSTALL_DIR="$unix_path" fi ! if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then ! POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME" ! else ! POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME" fi - $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL" ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="well-known location in VCINSTALLDIR" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} - # Need to check if the found msvcr is correct architecture - { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 - $as_echo_n "checking found $DLL_NAME architecture... " >&6; } - MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" - # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. - if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then - CORRECT_MSVCR_ARCH="PE32 executable" else ! CORRECT_MSVCR_ARCH="PE32+ executable" fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 fi fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else --- 50113,50248 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" ! ! # Only process if variable expands to non-empty ! ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" fi fi ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi fi ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" fi ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 fi + + MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" fi ! fi ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else
*** 50079,50098 **** { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi - fi - fi - if test "x$MSVC_DLL" = x; then ! # Probe: Check in the Boot JDK directory. ! POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME" ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="well-known location in Boot JDK" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} # Need to check if the found msvcr is correct architecture --- 50251,50269 ---- { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi if test "x$MSVC_DLL" = x; then ! as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5 ! fi ! MSVCR_DLL="$MSVC_DLL" ! elif test "x$DEVKIT_MSVCR_DLL" != x; then ! DLL_NAME="$MSVCR_NAME" ! POSSIBLE_MSVC_DLL="$DEVKIT_MSVCR_DLL" ! METHOD="devkit" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} # Need to check if the found msvcr is correct architecture
*** 50116,50250 **** fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 - $as_echo "$MSVC_DLL" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 - $as_echo "incorrect, ignoring" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 - $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} - fi - fi - - fi ! if test "x$MSVC_DLL" = x; then ! # Probe: Look in the Windows system32 directory ! CYGWIN_SYSTEMROOT="$SYSTEMROOT" ! windows_path="$CYGWIN_SYSTEMROOT" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then - unix_path=`$CYGPATH -u "$windows_path"` - CYGWIN_SYSTEMROOT="$unix_path" - elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` - CYGWIN_SYSTEMROOT="$unix_path" - fi ! POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME" ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="well-known location in SYSTEMROOT" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} ! # Need to check if the found msvcr is correct architecture ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 ! $as_echo_n "checking found $DLL_NAME architecture... " >&6; } ! MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" ! # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH="PE32 executable" ! else ! CORRECT_MSVCR_ARCH="PE32+ executable" fi - else - if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then - CORRECT_MSVCR_ARCH=386 - else - CORRECT_MSVCR_ARCH=x86-64 fi fi - if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 - $as_echo "ok" >&6; } - MSVC_DLL="$POSSIBLE_MSVC_DLL" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 - $as_echo "$MSVC_DLL" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 - $as_echo "incorrect, ignoring" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 - $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi fi - if test "x$MSVC_DLL" = x; then - # Probe: If Visual Studio Express is installed, there is usually one with the debugger - if test "x$VS100COMNTOOLS" != x; then - CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.." ! windows_path="$CYGWIN_VS_TOOLS_DIR" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then unix_path=`$CYGPATH -u "$windows_path"` ! CYGWIN_VS_TOOLS_DIR="$unix_path" elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! CYGWIN_VS_TOOLS_DIR="$unix_path" fi ! if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \ ! | $GREP -i /x64/ | $HEAD --lines 1` ! else ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \ ! | $GREP -i /x86/ | $HEAD --lines 1` fi ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="search of VS100COMNTOOLS" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} - # Need to check if the found msvcr is correct architecture - { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 - $as_echo_n "checking found $DLL_NAME architecture... " >&6; } - MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` - if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then - # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" - # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. - if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then - CORRECT_MSVCR_ARCH="PE32 executable" else ! CORRECT_MSVCR_ARCH="PE32+ executable" fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 fi fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else --- 50287,50422 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" ! # Only process if variable expands to non-empty ! if test "x$MSVC_DLL" != x; then if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" fi fi + + test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` + if test "x$test_cygdrive_prefix" = x; then + # As a simple fix, exclude /usr/bin since it's not a real path. + if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then + # The path is in a Cygwin special directory (e.g. /home). We need this converted to + # a path prefixed by /cygdrive for fixpath to work. + new_path="$CYGWIN_ROOT_PATH$input_path" fi fi + + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + + path="$MSVC_DLL" + has_colon=`$ECHO $path | $GREP ^.:` + new_path="$path" + if test "x$has_colon" = x; then + # Not in mixed or Windows style, start by that. + new_path=`cmd //c echo $path` fi ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" fi ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 fi + + MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" fi ! fi ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else
*** 50253,50286 **** { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi fi ! fi if test "x$MSVC_DLL" = x; then ! # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now. ! # (This was the original behaviour; kept since it might turn something up) ! if test "x$CYGWIN_VC_INSTALL_DIR" != x; then if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ ! | $GREP x64 | $HEAD --lines 1` else ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ ! | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1` ! if test "x$POSSIBLE_MSVC_DLL" = x; then ! # We're grasping at straws now... ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ ! | $HEAD --lines 1` ! fi fi ! DLL_NAME="$DLL_NAME" POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="search of VCINSTALLDIR" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} # Need to check if the found msvcr is correct architecture --- 50425,50467 ---- { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi + if test "x$MSVC_DLL" = x; then + as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by devkit" "$LINENO" 5 fi ! MSVCR_DLL="$MSVC_DLL" ! else ! ! DLL_NAME="${MSVCR_NAME}" ! MSVC_DLL= if test "x$MSVC_DLL" = x; then ! # Probe: Using well-known location from Visual Studio 10.0 ! if test "x$VCINSTALLDIR" != x; then ! CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR" ! ! windows_path="$CYGWIN_VC_INSTALL_DIR" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! CYGWIN_VC_INSTALL_DIR="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! CYGWIN_VC_INSTALL_DIR="$unix_path" ! fi ! if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then ! POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME" else ! POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME" fi ! $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL" DLL_NAME="$DLL_NAME" POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="well-known location in VCINSTALLDIR" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} # Need to check if the found msvcr is correct architecture
*** 50304,50346 **** fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 - $as_echo "$MSVC_DLL" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 - $as_echo "incorrect, ignoring" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 - $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} - fi - fi - - fi - fi - - if test "x$MSVC_DLL" = x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 - $as_echo "no" >&6; } - as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5 - fi - - MSVCR_DLL=$MSVC_DLL # Only process if variable expands to non-empty ! if test "x$MSVCR_DLL" != x; then if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then # Input might be given as Windows format, start by converting to # unix format. ! path="$MSVCR_DLL" new_path=`$CYGPATH -u "$path"` # Cygwin tries to hide some aspects of the Windows file system, such that binaries are # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then --- 50485,50503 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" # Only process if variable expands to non-empty ! if test "x$MSVC_DLL" != x; then if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then # Input might be given as Windows format, start by converting to # unix format. ! path="$MSVC_DLL" new_path=`$CYGPATH -u "$path"` # Cygwin tries to hide some aspects of the Windows file system, such that binaries are # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
*** 50348,50360 **** # # This test is therefore slightly more accurate than "test -f" to check for file precense. # It is also a way to make sure we got the proper file name for the real test later on. test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVCR_DLL" "$LINENO" 5 fi # Call helper function which possibly converts this using DOS-style short mode. # If so, the updated path is stored in $new_path. --- 50505,50517 ---- # # This test is therefore slightly more accurate than "test -f" to check for file precense. # It is also a way to make sure we got the proper file name for the real test later on. test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 fi # Call helper function which possibly converts this using DOS-style short mode. # If so, the updated path is stored in $new_path.
*** 50370,50380 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 50527,50537 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 50388,50405 **** fi fi if test "x$path" != "x$new_path"; then ! MSVCR_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;} fi elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! path="$MSVCR_DLL" has_colon=`$ECHO $path | $GREP ^.:` new_path="$path" if test "x$has_colon" = x; then # Not in mixed or Windows style, start by that. new_path=`cmd //c echo $path` --- 50545,50562 ---- fi fi if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! path="$MSVC_DLL" has_colon=`$ECHO $path | $GREP ^.:` new_path="$path" if test "x$has_colon" = x; then # Not in mixed or Windows style, start by that. new_path=`cmd //c echo $path`
*** 50426,50482 **** unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` new_path="$unix_path" fi if test "x$path" != "x$new_path"; then ! MSVCR_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;} fi # Save the first 10 bytes of this path to the storage, so fixpath can work. all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") else # We're on a unix platform. Hooray! :) ! path="$MSVCR_DLL" has_space=`$ECHO "$path" | $GREP " "` if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;} as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 fi # Use eval to expand a potential ~ eval path="$path" if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 fi ! MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`" fi fi ! MSVCR_DLL=$MSVCR_DLL ! ! fi ! # Check whether --with-msvcp-dll was given. ! if test "${with_msvcp_dll+set}" = set; then : ! withval=$with_msvcp_dll; ! fi ! ! ! if test "x$MSVCP_NAME" != "x"; then ! if test "x$with_msvcp_dll" != x; then ! # If given explicitely by user, do not probe. If not present, fail directly. DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$with_msvcp_dll" ! METHOD="--with-msvcp-dll" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} # Need to check if the found msvcr is correct architecture --- 50583,50642 ---- unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` new_path="$unix_path" fi if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi # Save the first 10 bytes of this path to the storage, so fixpath can work. all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") else # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" has_space=`$ECHO "$path" | $GREP " "` if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 fi # Use eval to expand a potential ~ eval path="$path" if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 fi ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" fi fi ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi fi + fi + fi ! if test "x$MSVC_DLL" = x; then ! # Probe: Check in the Boot JDK directory. ! POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME" DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="well-known location in Boot JDK" if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} # Need to check if the found msvcr is correct architecture
*** 50500,50534 **** fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 - $as_echo "$MSVC_DLL" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 - $as_echo "incorrect, ignoring" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 - $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} - fi - fi ! if test "x$MSVC_DLL" = x; then ! as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5 ! fi ! else ! VAR_NAME="MSVCP_DLL" ! DLL_NAME="${MSVCP_NAME}" ! MSVC_DLL= ! if test "x$MSVC_DLL" = x; then ! # Probe: Using well-known location from Visual Studio 10.0 ! if test "x$VCINSTALLDIR" != x; then ! CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR" windows_path="$CYGWIN_VC_INSTALL_DIR" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then unix_path=`$CYGPATH -u "$windows_path"` CYGWIN_VC_INSTALL_DIR="$unix_path" --- 50660,51754 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" ! # Only process if variable expands to non-empty ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" ! fi ! fi ! ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi ! fi ! ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" ! fi ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") ! ! else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 ! fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi ! fi ! ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi ! fi ! ! fi ! ! if test "x$MSVC_DLL" = x; then ! # Probe: Look in the Windows system32 directory ! CYGWIN_SYSTEMROOT="$SYSTEMROOT" ! ! windows_path="$CYGWIN_SYSTEMROOT" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! CYGWIN_SYSTEMROOT="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! CYGWIN_SYSTEMROOT="$unix_path" ! fi ! ! POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME" ! ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="well-known location in SYSTEMROOT" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} ! ! # Need to check if the found msvcr is correct architecture ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 ! $as_echo_n "checking found $DLL_NAME architecture... " >&6; } ! MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" ! # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH="PE32 executable" ! else ! CORRECT_MSVCR_ARCH="PE32+ executable" ! fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 ! fi ! fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" ! ! # Only process if variable expands to non-empty ! ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" ! fi ! fi ! ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi ! fi ! ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" ! fi ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") ! ! else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 ! fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi ! fi ! ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi ! fi ! ! fi ! ! if test "x$MSVC_DLL" = x; then ! # Probe: If Visual Studio Express is installed, there is usually one with the debugger ! if test "x$VS100COMNTOOLS" != x; then ! CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.." ! ! windows_path="$CYGWIN_VS_TOOLS_DIR" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! CYGWIN_VS_TOOLS_DIR="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! CYGWIN_VS_TOOLS_DIR="$unix_path" ! fi ! ! if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \ ! | $GREP -i /x64/ | $HEAD --lines 1` ! else ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \ ! | $GREP -i /x86/ | $HEAD --lines 1` ! fi ! ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="search of VS100COMNTOOLS" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} ! ! # Need to check if the found msvcr is correct architecture ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 ! $as_echo_n "checking found $DLL_NAME architecture... " >&6; } ! MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" ! # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH="PE32 executable" ! else ! CORRECT_MSVCR_ARCH="PE32+ executable" ! fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 ! fi ! fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" ! ! # Only process if variable expands to non-empty ! ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" ! fi ! fi ! ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi ! fi ! ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" ! fi ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") ! ! else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 ! fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi ! fi ! ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi ! fi ! ! fi ! fi ! ! if test "x$MSVC_DLL" = x; then ! # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now. ! # (This was the original behaviour; kept since it might turn something up) ! if test "x$CYGWIN_VC_INSTALL_DIR" != x; then ! if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ ! | $GREP x64 | $HEAD --lines 1` ! else ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ ! | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1` ! if test "x$POSSIBLE_MSVC_DLL" = x; then ! # We're grasping at straws now... ! POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \ ! | $HEAD --lines 1` ! fi ! fi ! ! ! DLL_NAME="$DLL_NAME" ! POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL" ! METHOD="search of VCINSTALLDIR" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} ! ! # Need to check if the found msvcr is correct architecture ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 ! $as_echo_n "checking found $DLL_NAME architecture... " >&6; } ! MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" ! # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH="PE32 executable" ! else ! CORRECT_MSVCR_ARCH="PE32+ executable" ! fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 ! fi ! fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" ! ! # Only process if variable expands to non-empty ! ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" ! fi ! fi ! ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi ! fi ! ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" ! fi ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") ! ! else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 ! fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi ! fi ! ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi ! fi ! ! fi ! fi ! ! if test "x$MSVC_DLL" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 ! $as_echo "no" >&6; } ! as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5 ! fi ! ! MSVCR_DLL="$MSVC_DLL" ! fi ! ! ! ! # Check whether --with-msvcp-dll was given. ! if test "${with_msvcp_dll+set}" = set; then : ! withval=$with_msvcp_dll; ! fi ! ! ! if test "x$MSVCP_NAME" != "x"; then ! if test "x$with_msvcp_dll" != x; then ! # If given explicitely by user, do not probe. If not present, fail directly. ! ! DLL_NAME="$MSVCP_NAME" ! POSSIBLE_MSVC_DLL="$with_msvcp_dll" ! METHOD="--with-msvcp-dll" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} ! ! # Need to check if the found msvcr is correct architecture ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 ! $as_echo_n "checking found $DLL_NAME architecture... " >&6; } ! MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" ! # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH="PE32 executable" ! else ! CORRECT_MSVCR_ARCH="PE32+ executable" ! fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 ! fi ! fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" ! ! # Only process if variable expands to non-empty ! ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" ! fi ! fi ! ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi ! fi ! ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" ! fi ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") ! ! else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 ! fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi ! fi ! ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi ! fi ! ! if test "x$MSVC_DLL" = x; then ! as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5 ! fi ! MSVCP_DLL="$MSVC_DLL" ! elif test "x$DEVKIT_MSVCP_DLL" != x; then ! ! DLL_NAME="$MSVCP_NAME" ! POSSIBLE_MSVC_DLL="$DEVKIT_MSVCP_DLL" ! METHOD="devkit" ! if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5 ! $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;} ! ! # Need to check if the found msvcr is correct architecture ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5 ! $as_echo_n "checking found $DLL_NAME architecture... " >&6; } ! MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"` ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit" ! # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems. ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH="PE32 executable" ! else ! CORRECT_MSVCR_ARCH="PE32+ executable" ! fi ! else ! if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then ! CORRECT_MSVCR_ARCH=386 ! else ! CORRECT_MSVCR_ARCH=x86-64 ! fi ! fi ! if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 ! $as_echo "ok" >&6; } ! MSVC_DLL="$POSSIBLE_MSVC_DLL" ! ! # Only process if variable expands to non-empty ! ! if test "x$MSVC_DLL" != x; then ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! ! # Input might be given as Windows format, start by converting to ! # unix format. ! path="$MSVC_DLL" ! new_path=`$CYGPATH -u "$path"` ! ! # Cygwin tries to hide some aspects of the Windows file system, such that binaries are ! # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered ! # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then ! # "foo.exe" is OK but "foo" is an error. ! # ! # This test is therefore slightly more accurate than "test -f" to check for file precense. ! # It is also a way to make sure we got the proper file name for the real test later on. ! test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` ! if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 ! fi ! ! # Call helper function which possibly converts this using DOS-style short mode. ! # If so, the updated path is stored in $new_path. ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! shortmode_path=`$CYGPATH -s -m -a "$input_path"` ! path_after_shortmode=`$CYGPATH -u "$shortmode_path"` ! if test "x$path_after_shortmode" != "x$input_to_shortpath"; then ! # Going to short mode and back again did indeed matter. Since short mode is ! # case insensitive, let's make it lowercase to improve readability. ! shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) ! input_path=`$CYGPATH -u "$shortmode_path"` ! new_path="$input_path" ! fi ! fi ! ! test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` ! if test "x$test_cygdrive_prefix" = x; then ! # As a simple fix, exclude /usr/bin since it's not a real path. ! if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then ! # The path is in a Cygwin special directory (e.g. /home). We need this converted to ! # a path prefixed by /cygdrive for fixpath to work. ! new_path="$CYGWIN_ROOT_PATH$input_path" ! fi ! fi ! ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! ! path="$MSVC_DLL" ! has_colon=`$ECHO $path | $GREP ^.:` ! new_path="$path" ! if test "x$has_colon" = x; then ! # Not in mixed or Windows style, start by that. ! new_path=`cmd //c echo $path` ! fi ! ! ! input_path="$new_path" ! # Check if we need to convert this using DOS-style short mode. If the path ! # contains just simple characters, use it. Otherwise (spaces, weird characters), ! # take no chances and rewrite it. ! # Note: m4 eats our [], so we need to use [ and ] instead. ! has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` ! if test "x$has_forbidden_chars" != x; then ! # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) ! new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! fi ! ! ! windows_path="$new_path" ! if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then ! unix_path=`$CYGPATH -u "$windows_path"` ! new_path="$unix_path" ! elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` ! new_path="$unix_path" ! fi ! ! if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} ! fi ! ! # Save the first 10 bytes of this path to the storage, so fixpath can work. ! all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") ! ! else ! # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" ! has_space=`$ECHO "$path" | $GREP " "` ! if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 ! fi ! ! # Use eval to expand a potential ~ ! eval path="$path" ! if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi ! fi ! ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} ! fi ! fi ! ! if test "x$MSVC_DLL" = x; then ! as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by devkit" "$LINENO" 5 ! fi ! MSVCP_DLL="$MSVC_DLL" ! else ! ! DLL_NAME="${MSVCP_NAME}" ! MSVC_DLL= ! ! if test "x$MSVC_DLL" = x; then ! # Probe: Using well-known location from Visual Studio 10.0 ! if test "x$VCINSTALLDIR" != x; then ! CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR" windows_path="$CYGWIN_VC_INSTALL_DIR" if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then unix_path=`$CYGPATH -u "$windows_path"` CYGWIN_VC_INSTALL_DIR="$unix_path"
*** 50572,50581 **** --- 51792,51927 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" + + # Only process if variable expands to non-empty + + if test "x$MSVC_DLL" != x; then + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + + # Input might be given as Windows format, start by converting to + # unix format. + path="$MSVC_DLL" + new_path=`$CYGPATH -u "$path"` + + # Cygwin tries to hide some aspects of the Windows file system, such that binaries are + # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered + # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then + # "foo.exe" is OK but "foo" is an error. + # + # This test is therefore slightly more accurate than "test -f" to check for file precense. + # It is also a way to make sure we got the proper file name for the real test later on. + test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` + if test "x$test_shortpath" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 + fi + + # Call helper function which possibly converts this using DOS-style short mode. + # If so, the updated path is stored in $new_path. + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + shortmode_path=`$CYGPATH -s -m -a "$input_path"` + path_after_shortmode=`$CYGPATH -u "$shortmode_path"` + if test "x$path_after_shortmode" != "x$input_to_shortpath"; then + # Going to short mode and back again did indeed matter. Since short mode is + # case insensitive, let's make it lowercase to improve readability. + shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Now convert it back to Unix-style (cygpath) + input_path=`$CYGPATH -u "$shortmode_path"` + new_path="$input_path" + fi + fi + + test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` + if test "x$test_cygdrive_prefix" = x; then + # As a simple fix, exclude /usr/bin since it's not a real path. + if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then + # The path is in a Cygwin special directory (e.g. /home). We need this converted to + # a path prefixed by /cygdrive for fixpath to work. + new_path="$CYGWIN_ROOT_PATH$input_path" + fi + fi + + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + + path="$MSVC_DLL" + has_colon=`$ECHO $path | $GREP ^.:` + new_path="$path" + if test "x$has_colon" = x; then + # Not in mixed or Windows style, start by that. + new_path=`cmd //c echo $path` + fi + + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + fi + + + windows_path="$new_path" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + unix_path=`$CYGPATH -u "$windows_path"` + new_path="$unix_path" + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` + new_path="$unix_path" + fi + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + # Save the first 10 bytes of this path to the storage, so fixpath can work. + all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") + + else + # We're on a unix platform. Hooray! :) + path="$MSVC_DLL" + has_space=`$ECHO "$path" | $GREP " "` + if test "x$has_space" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 + fi + + # Use eval to expand a potential ~ + eval path="$path" + if test ! -f "$path" && test ! -d "$path"; then + as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 + fi + + MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" + fi + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else
*** 50621,50630 **** --- 51967,52102 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" + + # Only process if variable expands to non-empty + + if test "x$MSVC_DLL" != x; then + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + + # Input might be given as Windows format, start by converting to + # unix format. + path="$MSVC_DLL" + new_path=`$CYGPATH -u "$path"` + + # Cygwin tries to hide some aspects of the Windows file system, such that binaries are + # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered + # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then + # "foo.exe" is OK but "foo" is an error. + # + # This test is therefore slightly more accurate than "test -f" to check for file precense. + # It is also a way to make sure we got the proper file name for the real test later on. + test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` + if test "x$test_shortpath" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 + fi + + # Call helper function which possibly converts this using DOS-style short mode. + # If so, the updated path is stored in $new_path. + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + shortmode_path=`$CYGPATH -s -m -a "$input_path"` + path_after_shortmode=`$CYGPATH -u "$shortmode_path"` + if test "x$path_after_shortmode" != "x$input_to_shortpath"; then + # Going to short mode and back again did indeed matter. Since short mode is + # case insensitive, let's make it lowercase to improve readability. + shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Now convert it back to Unix-style (cygpath) + input_path=`$CYGPATH -u "$shortmode_path"` + new_path="$input_path" + fi + fi + + test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` + if test "x$test_cygdrive_prefix" = x; then + # As a simple fix, exclude /usr/bin since it's not a real path. + if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then + # The path is in a Cygwin special directory (e.g. /home). We need this converted to + # a path prefixed by /cygdrive for fixpath to work. + new_path="$CYGWIN_ROOT_PATH$input_path" + fi + fi + + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + + path="$MSVC_DLL" + has_colon=`$ECHO $path | $GREP ^.:` + new_path="$path" + if test "x$has_colon" = x; then + # Not in mixed or Windows style, start by that. + new_path=`cmd //c echo $path` + fi + + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + fi + + + windows_path="$new_path" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + unix_path=`$CYGPATH -u "$windows_path"` + new_path="$unix_path" + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` + new_path="$unix_path" + fi + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + # Save the first 10 bytes of this path to the storage, so fixpath can work. + all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") + + else + # We're on a unix platform. Hooray! :) + path="$MSVC_DLL" + has_space=`$ECHO "$path" | $GREP " "` + if test "x$has_space" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 + fi + + # Use eval to expand a potential ~ + eval path="$path" + if test ! -f "$path" && test ! -d "$path"; then + as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 + fi + + MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" + fi + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else
*** 50680,50689 **** --- 52152,52287 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" + + # Only process if variable expands to non-empty + + if test "x$MSVC_DLL" != x; then + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + + # Input might be given as Windows format, start by converting to + # unix format. + path="$MSVC_DLL" + new_path=`$CYGPATH -u "$path"` + + # Cygwin tries to hide some aspects of the Windows file system, such that binaries are + # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered + # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then + # "foo.exe" is OK but "foo" is an error. + # + # This test is therefore slightly more accurate than "test -f" to check for file precense. + # It is also a way to make sure we got the proper file name for the real test later on. + test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` + if test "x$test_shortpath" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 + fi + + # Call helper function which possibly converts this using DOS-style short mode. + # If so, the updated path is stored in $new_path. + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + shortmode_path=`$CYGPATH -s -m -a "$input_path"` + path_after_shortmode=`$CYGPATH -u "$shortmode_path"` + if test "x$path_after_shortmode" != "x$input_to_shortpath"; then + # Going to short mode and back again did indeed matter. Since short mode is + # case insensitive, let's make it lowercase to improve readability. + shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Now convert it back to Unix-style (cygpath) + input_path=`$CYGPATH -u "$shortmode_path"` + new_path="$input_path" + fi + fi + + test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` + if test "x$test_cygdrive_prefix" = x; then + # As a simple fix, exclude /usr/bin since it's not a real path. + if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then + # The path is in a Cygwin special directory (e.g. /home). We need this converted to + # a path prefixed by /cygdrive for fixpath to work. + new_path="$CYGWIN_ROOT_PATH$input_path" + fi + fi + + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + + path="$MSVC_DLL" + has_colon=`$ECHO $path | $GREP ^.:` + new_path="$path" + if test "x$has_colon" = x; then + # Not in mixed or Windows style, start by that. + new_path=`cmd //c echo $path` + fi + + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + fi + + + windows_path="$new_path" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + unix_path=`$CYGPATH -u "$windows_path"` + new_path="$unix_path" + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` + new_path="$unix_path" + fi + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + # Save the first 10 bytes of this path to the storage, so fixpath can work. + all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") + + else + # We're on a unix platform. Hooray! :) + path="$MSVC_DLL" + has_space=`$ECHO "$path" | $GREP " "` + if test "x$has_space" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 + fi + + # Use eval to expand a potential ~ + eval path="$path" + if test ! -f "$path" && test ! -d "$path"; then + as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 + fi + + MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" + fi + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else
*** 50746,50755 **** --- 52344,52479 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" + + # Only process if variable expands to non-empty + + if test "x$MSVC_DLL" != x; then + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + + # Input might be given as Windows format, start by converting to + # unix format. + path="$MSVC_DLL" + new_path=`$CYGPATH -u "$path"` + + # Cygwin tries to hide some aspects of the Windows file system, such that binaries are + # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered + # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then + # "foo.exe" is OK but "foo" is an error. + # + # This test is therefore slightly more accurate than "test -f" to check for file precense. + # It is also a way to make sure we got the proper file name for the real test later on. + test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` + if test "x$test_shortpath" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 + fi + + # Call helper function which possibly converts this using DOS-style short mode. + # If so, the updated path is stored in $new_path. + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + shortmode_path=`$CYGPATH -s -m -a "$input_path"` + path_after_shortmode=`$CYGPATH -u "$shortmode_path"` + if test "x$path_after_shortmode" != "x$input_to_shortpath"; then + # Going to short mode and back again did indeed matter. Since short mode is + # case insensitive, let's make it lowercase to improve readability. + shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Now convert it back to Unix-style (cygpath) + input_path=`$CYGPATH -u "$shortmode_path"` + new_path="$input_path" + fi + fi + + test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/` + if test "x$test_cygdrive_prefix" = x; then + # As a simple fix, exclude /usr/bin since it's not a real path. + if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then + # The path is in a Cygwin special directory (e.g. /home). We need this converted to + # a path prefixed by /cygdrive for fixpath to work. + new_path="$CYGWIN_ROOT_PATH$input_path" + fi + fi + + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + + path="$MSVC_DLL" + has_colon=`$ECHO $path | $GREP ^.:` + new_path="$path" + if test "x$has_colon" = x; then + # Not in mixed or Windows style, start by that. + new_path=`cmd //c echo $path` + fi + + + input_path="$new_path" + # Check if we need to convert this using DOS-style short mode. If the path + # contains just simple characters, use it. Otherwise (spaces, weird characters), + # take no chances and rewrite it. + # Note: m4 eats our [], so we need to use [ and ] instead. + has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]` + if test "x$has_forbidden_chars" != x; then + # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \) + new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + fi + + + windows_path="$new_path" + if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then + unix_path=`$CYGPATH -u "$windows_path"` + new_path="$unix_path" + elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then + unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` + new_path="$unix_path" + fi + + if test "x$path" != "x$new_path"; then + MSVC_DLL="$new_path" + { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 + $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} + fi + + # Save the first 10 bytes of this path to the storage, so fixpath can work. + all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") + + else + # We're on a unix platform. Hooray! :) + path="$MSVC_DLL" + has_space=`$ECHO "$path" | $GREP " "` + if test "x$has_space" != x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 + $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} + as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 + fi + + # Use eval to expand a potential ~ + eval path="$path" + if test ! -f "$path" && test ! -d "$path"; then + as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 + fi + + MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" + fi + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 $as_echo_n "checking for $DLL_NAME... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 $as_echo "$MSVC_DLL" >&6; } else
*** 50809,50851 **** fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 - $as_echo "$MSVC_DLL" >&6; } - else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 - $as_echo "incorrect, ignoring" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 - $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} - fi - fi - - fi - fi - - if test "x$MSVC_DLL" = x; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 - $as_echo_n "checking for $DLL_NAME... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 - $as_echo "no" >&6; } - as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5 - fi - - MSVCP_DLL=$MSVC_DLL # Only process if variable expands to non-empty ! if test "x$MSVCP_DLL" != x; then if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then # Input might be given as Windows format, start by converting to # unix format. ! path="$MSVCP_DLL" new_path=`$CYGPATH -u "$path"` # Cygwin tries to hide some aspects of the Windows file system, such that binaries are # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then --- 52533,52551 ---- fi if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 $as_echo "ok" >&6; } MSVC_DLL="$POSSIBLE_MSVC_DLL" # Only process if variable expands to non-empty ! if test "x$MSVC_DLL" != x; then if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then # Input might be given as Windows format, start by converting to # unix format. ! path="$MSVC_DLL" new_path=`$CYGPATH -u "$path"` # Cygwin tries to hide some aspects of the Windows file system, such that binaries are # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
*** 50853,50865 **** # # This test is therefore slightly more accurate than "test -f" to check for file precense. # It is also a way to make sure we got the proper file name for the real test later on. test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVCP_DLL" "$LINENO" 5 fi # Call helper function which possibly converts this using DOS-style short mode. # If so, the updated path is stored in $new_path. --- 52553,52565 ---- # # This test is therefore slightly more accurate than "test -f" to check for file precense. # It is also a way to make sure we got the proper file name for the real test later on. test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null` if test "x$test_shortpath" = x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} ! as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5 fi # Call helper function which possibly converts this using DOS-style short mode. # If so, the updated path is stored in $new_path.
*** 50875,50885 **** path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-stile (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi --- 52575,52585 ---- path_after_shortmode=`$CYGPATH -u "$shortmode_path"` if test "x$path_after_shortmode" != "x$input_to_shortpath"; then # Going to short mode and back again did indeed matter. Since short mode is # case insensitive, let's make it lowercase to improve readability. shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` ! # Now convert it back to Unix-style (cygpath) input_path=`$CYGPATH -u "$shortmode_path"` new_path="$input_path" fi fi
*** 50893,50910 **** fi fi if test "x$path" != "x$new_path"; then ! MSVCP_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;} fi elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! path="$MSVCP_DLL" has_colon=`$ECHO $path | $GREP ^.:` new_path="$path" if test "x$has_colon" = x; then # Not in mixed or Windows style, start by that. new_path=`cmd //c echo $path` --- 52593,52610 ---- fi fi if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then ! path="$MSVC_DLL" has_colon=`$ECHO $path | $GREP ^.:` new_path="$path" if test "x$has_colon" = x; then # Not in mixed or Windows style, start by that. new_path=`cmd //c echo $path`
*** 50931,50972 **** unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` new_path="$unix_path" fi if test "x$path" != "x$new_path"; then ! MSVCP_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;} fi # Save the first 10 bytes of this path to the storage, so fixpath can work. all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") else # We're on a unix platform. Hooray! :) ! path="$MSVCP_DLL" has_space=`$ECHO "$path" | $GREP " "` if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;} as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 fi # Use eval to expand a potential ~ eval path="$path" if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVCP_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 fi ! MSVCP_DLL="`cd "$path"; $THEPWDCMD -L`" fi fi ! MSVCP_DLL=$MSVCP_DLL fi fi # Check whether --with-dxsdk was given. --- 52631,52694 ---- unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'` new_path="$unix_path" fi if test "x$path" != "x$new_path"; then ! MSVC_DLL="$new_path" ! { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5 ! $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;} fi # Save the first 10 bytes of this path to the storage, so fixpath can work. all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}") else # We're on a unix platform. Hooray! :) ! path="$MSVC_DLL" has_space=`$ECHO "$path" | $GREP " "` if test "x$has_space" != x; then ! { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5 ! $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;} as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5 fi # Use eval to expand a potential ~ eval path="$path" if test ! -f "$path" && test ! -d "$path"; then ! as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5 ! fi ! ! MSVC_DLL="`cd "$path"; $THEPWDCMD -L`" ! fi fi ! { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 ! $as_echo_n "checking for $DLL_NAME... " >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5 ! $as_echo "$MSVC_DLL" >&6; } ! else ! { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5 ! $as_echo "incorrect, ignoring" >&6; } ! { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5 ! $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;} fi fi ! fi ! fi + if test "x$MSVC_DLL" = x; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5 + $as_echo_n "checking for $DLL_NAME... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 + $as_echo "no" >&6; } + as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5 + fi + MSVCP_DLL="$MSVC_DLL" fi + fi # Check whether --with-dxsdk was given.
< prev index next >