3387 # $2: executable name (or list of names) to look for
3388
3389
3390 # Like BASIC_PATH_PROGS but fails if no tool was found.
3391 # $1: variable to set
3392 # $2: executable name (or list of names) to look for
3393
3394
3395 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3396 # $1: variable to set
3397 # $2: autoconf macro to call to look for the special tool
3398
3399
3400 # Setup the most fundamental tools that relies on not much else to set up,
3401 # but is used by much of the early bootstrap code.
3402
3403
3404 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414 #%%% Simple tools %%%
3415
3416 # Check if we have found a usable version of make
3417 # $1: the path to a potential make binary (or empty)
3418 # $2: the description on how we found this
3419
3420
3421 # Goes looking for a usable version of GNU make.
3422
3423
3424
3425
3426
4284
4285
4286
4287
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298 # This line needs to be here, verbatim, after all includes and the dummy hook
4299 # definitions. It is replaced with custom functionality when building
4300 # custom sources.
4301 #CUSTOM_AUTOCONF_INCLUDE
4302
4303 # Do not change or remove the following line, it is needed for consistency checks:
4304 DATE_WHEN_GENERATED=1526507291
4305
4306 ###############################################################################
4307 #
4308 # Initialization / Boot-strapping
4309 #
4310 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4311 # thus it jumps back and forth, each time gaining something needed later on.
4312 #
4313 ###############################################################################
4314
4315 # If we are requested to print additional help, do that and then exit.
4316 # This must be the very first call.
4317
4318 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4319 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4320 $PRINTF "Which are valid to use depends on the build platform.\n"
4321 for toolchain in $VALID_TOOLCHAINS_all; do
4322 # Use indirect variable referencing
4323 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4324 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
14100 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14101 fi
14102
14103 # Call helper function which possibly converts this using DOS-style short mode.
14104 # If so, the updated path is stored in $new_path.
14105
14106 input_path="$new_path"
14107 # Check if we need to convert this using DOS-style short mode. If the path
14108 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14109 # take no chances and rewrite it.
14110 # Note: m4 eats our [], so we need to use [ and ] instead.
14111 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14112 if test "x$has_forbidden_chars" != x; then
14113 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14114 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14115 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14116 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14117 # Going to short mode and back again did indeed matter. Since short mode is
14118 # case insensitive, let's make it lowercase to improve readability.
14119 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14120 # Now convert it back to Unix-stile (cygpath)
14121 input_path=`$CYGPATH -u "$shortmode_path"`
14122 new_path="$input_path"
14123 fi
14124 fi
14125
14126 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14127 if test "x$test_cygdrive_prefix" = x; then
14128 # As a simple fix, exclude /usr/bin since it's not a real path.
14129 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14130 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14131 # a path prefixed by /cygdrive for fixpath to work.
14132 new_path="$CYGWIN_ROOT_PATH$input_path"
14133 fi
14134 fi
14135
14136
14137 if test "x$path" != "x$new_path"; then
14138 CURDIR="$new_path"
14139 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14140 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14222 as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14223 fi
14224
14225 # Call helper function which possibly converts this using DOS-style short mode.
14226 # If so, the updated path is stored in $new_path.
14227
14228 input_path="$new_path"
14229 # Check if we need to convert this using DOS-style short mode. If the path
14230 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14231 # take no chances and rewrite it.
14232 # Note: m4 eats our [], so we need to use [ and ] instead.
14233 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14234 if test "x$has_forbidden_chars" != x; then
14235 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14236 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14237 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14238 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14239 # Going to short mode and back again did indeed matter. Since short mode is
14240 # case insensitive, let's make it lowercase to improve readability.
14241 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14242 # Now convert it back to Unix-stile (cygpath)
14243 input_path=`$CYGPATH -u "$shortmode_path"`
14244 new_path="$input_path"
14245 fi
14246 fi
14247
14248 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14249 if test "x$test_cygdrive_prefix" = x; then
14250 # As a simple fix, exclude /usr/bin since it's not a real path.
14251 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14252 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14253 # a path prefixed by /cygdrive for fixpath to work.
14254 new_path="$CYGWIN_ROOT_PATH$input_path"
14255 fi
14256 fi
14257
14258
14259 if test "x$path" != "x$new_path"; then
14260 TOPDIR="$new_path"
14261 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14262 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14709 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14710 fi
14711
14712 # Call helper function which possibly converts this using DOS-style short mode.
14713 # If so, the updated path is stored in $new_path.
14714
14715 input_path="$new_path"
14716 # Check if we need to convert this using DOS-style short mode. If the path
14717 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14718 # take no chances and rewrite it.
14719 # Note: m4 eats our [], so we need to use [ and ] instead.
14720 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14721 if test "x$has_forbidden_chars" != x; then
14722 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14723 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14724 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14725 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14726 # Going to short mode and back again did indeed matter. Since short mode is
14727 # case insensitive, let's make it lowercase to improve readability.
14728 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14729 # Now convert it back to Unix-stile (cygpath)
14730 input_path=`$CYGPATH -u "$shortmode_path"`
14731 new_path="$input_path"
14732 fi
14733 fi
14734
14735 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14736 if test "x$test_cygdrive_prefix" = x; then
14737 # As a simple fix, exclude /usr/bin since it's not a real path.
14738 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14739 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14740 # a path prefixed by /cygdrive for fixpath to work.
14741 new_path="$CYGWIN_ROOT_PATH$input_path"
14742 fi
14743 fi
14744
14745
14746 if test "x$path" != "x$new_path"; then
14747 with_devkit="$new_path"
14748 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14749 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14795 path="$with_devkit"
14796 has_space=`$ECHO "$path" | $GREP " "`
14797 if test "x$has_space" != x; then
14798 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14799 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14800 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14801 fi
14802
14803 # Use eval to expand a potential ~
14804 eval path="$path"
14805 if test ! -f "$path" && test ! -d "$path"; then
14806 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14807 fi
14808
14809 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14810 fi
14811
14812 DEVKIT_ROOT="$with_devkit"
14813 # Check for a meta data info file in the root of the devkit
14814 if test -f "$DEVKIT_ROOT/devkit.info"; then
14815 # This potentially sets the following:
14816 # DEVKIT_NAME: A descriptive name of the devkit
14817 # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path
14818 # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path
14819 # DEVKIT_SYSROOT: Corresponds to --with-sysroot
14820 . $DEVKIT_ROOT/devkit.info
14821 fi
14822
14823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14824 $as_echo_n "checking for devkit... " >&6; }
14825 if test "x$DEVKIT_NAME" != x; then
14826 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14827 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14828 else
14829 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14830 $as_echo "$DEVKIT_ROOT" >&6; }
14831 fi
14832
14833 if test "x$DEVKIT_EXTRA_PATH" != x; then
14834
14835 if test "x$DEVKIT_EXTRA_PATH" != x; then
14836 if test "x$EXTRA_PATH" = x; then
14837 EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14838 else
14839 EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14840 fi
14841 fi
14842
14843 fi
14844
14845 # Fallback default of just /bin if DEVKIT_PATH is not defined
14846 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14847 DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14848 fi
14849
14850 if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14851 if test "x$TOOLCHAIN_PATH" = x; then
14852 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14853 else
14854 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14855 fi
14856 fi
14857
14858
14859 # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14860 # places for backwards compatiblity.
14861 if test "x$DEVKIT_SYSROOT" != x; then
14862 SYSROOT="$DEVKIT_SYSROOT"
14863 elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
15011 # We are running configure from outside of the src dir.
15012 # Then use the current directory as output dir!
15013 # If configuration is situated in normal build directory, just use the build
15014 # directory name as configuration name, otherwise use the complete path.
15015 if test "x${CONF_NAME}" = x; then
15016 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15017 fi
15018 OUTPUT_ROOT="$CURDIR"
15019 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15020 $as_echo "in current directory" >&6; }
15021
15022 # WARNING: This might be a bad thing to do. You need to be sure you want to
15023 # have a configuration in this directory. Do some sanity checks!
15024
15025 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15026 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15027 # other files
15028 files_present=`$LS $OUTPUT_ROOT`
15029 # Configure has already touched config.log and confdefs.h in the current dir when this check
15030 # is performed.
15031 filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
15032 | $TR -d '\n'`
15033 if test "x$filtered_files" != x; then
15034 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15035 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15036 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15037 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15038 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15039 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15040 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15041 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15042 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15043 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15044 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15045 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15046 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15047 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15048 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15049 fi
15050 fi
15051 fi
15076 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15077 fi
15078
15079 # Call helper function which possibly converts this using DOS-style short mode.
15080 # If so, the updated path is stored in $new_path.
15081
15082 input_path="$new_path"
15083 # Check if we need to convert this using DOS-style short mode. If the path
15084 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15085 # take no chances and rewrite it.
15086 # Note: m4 eats our [], so we need to use [ and ] instead.
15087 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15088 if test "x$has_forbidden_chars" != x; then
15089 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15090 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15091 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15092 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15093 # Going to short mode and back again did indeed matter. Since short mode is
15094 # case insensitive, let's make it lowercase to improve readability.
15095 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15096 # Now convert it back to Unix-stile (cygpath)
15097 input_path=`$CYGPATH -u "$shortmode_path"`
15098 new_path="$input_path"
15099 fi
15100 fi
15101
15102 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15103 if test "x$test_cygdrive_prefix" = x; then
15104 # As a simple fix, exclude /usr/bin since it's not a real path.
15105 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15106 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15107 # a path prefixed by /cygdrive for fixpath to work.
15108 new_path="$CYGWIN_ROOT_PATH$input_path"
15109 fi
15110 fi
15111
15112
15113 if test "x$path" != "x$new_path"; then
15114 OUTPUT_ROOT="$new_path"
15115 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15116 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15379 fi
15380
15381 # Call helper function which possibly converts this using DOS-style short mode.
15382 # If so, the updated path is stored in $new_path.
15383 new_path="$input_to_shortpath"
15384
15385 input_path="$input_to_shortpath"
15386 # Check if we need to convert this using DOS-style short mode. If the path
15387 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15388 # take no chances and rewrite it.
15389 # Note: m4 eats our [], so we need to use [ and ] instead.
15390 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15391 if test "x$has_forbidden_chars" != x; then
15392 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15393 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15394 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15395 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15396 # Going to short mode and back again did indeed matter. Since short mode is
15397 # case insensitive, let's make it lowercase to improve readability.
15398 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15399 # Now convert it back to Unix-stile (cygpath)
15400 input_path=`$CYGPATH -u "$shortmode_path"`
15401 new_path="$input_path"
15402 fi
15403 fi
15404
15405 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15406 if test "x$test_cygdrive_prefix" = x; then
15407 # As a simple fix, exclude /usr/bin since it's not a real path.
15408 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15409 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15410 # a path prefixed by /cygdrive for fixpath to work.
15411 new_path="$CYGWIN_ROOT_PATH$input_path"
15412 fi
15413 fi
15414
15415 # remove trailing .exe if any
15416 new_path="${new_path/%.exe/}"
15417
15418 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15419
15752 fi
15753
15754 # Call helper function which possibly converts this using DOS-style short mode.
15755 # If so, the updated path is stored in $new_path.
15756 new_path="$input_to_shortpath"
15757
15758 input_path="$input_to_shortpath"
15759 # Check if we need to convert this using DOS-style short mode. If the path
15760 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15761 # take no chances and rewrite it.
15762 # Note: m4 eats our [], so we need to use [ and ] instead.
15763 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15764 if test "x$has_forbidden_chars" != x; then
15765 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15766 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15767 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15768 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15769 # Going to short mode and back again did indeed matter. Since short mode is
15770 # case insensitive, let's make it lowercase to improve readability.
15771 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15772 # Now convert it back to Unix-stile (cygpath)
15773 input_path=`$CYGPATH -u "$shortmode_path"`
15774 new_path="$input_path"
15775 fi
15776 fi
15777
15778 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15779 if test "x$test_cygdrive_prefix" = x; then
15780 # As a simple fix, exclude /usr/bin since it's not a real path.
15781 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15782 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15783 # a path prefixed by /cygdrive for fixpath to work.
15784 new_path="$CYGWIN_ROOT_PATH$input_path"
15785 fi
15786 fi
15787
15788 # remove trailing .exe if any
15789 new_path="${new_path/%.exe/}"
15790
15791 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15792
16122 fi
16123
16124 # Call helper function which possibly converts this using DOS-style short mode.
16125 # If so, the updated path is stored in $new_path.
16126 new_path="$input_to_shortpath"
16127
16128 input_path="$input_to_shortpath"
16129 # Check if we need to convert this using DOS-style short mode. If the path
16130 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16131 # take no chances and rewrite it.
16132 # Note: m4 eats our [], so we need to use [ and ] instead.
16133 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16134 if test "x$has_forbidden_chars" != x; then
16135 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16136 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16137 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16138 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16139 # Going to short mode and back again did indeed matter. Since short mode is
16140 # case insensitive, let's make it lowercase to improve readability.
16141 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16142 # Now convert it back to Unix-stile (cygpath)
16143 input_path=`$CYGPATH -u "$shortmode_path"`
16144 new_path="$input_path"
16145 fi
16146 fi
16147
16148 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16149 if test "x$test_cygdrive_prefix" = x; then
16150 # As a simple fix, exclude /usr/bin since it's not a real path.
16151 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16152 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16153 # a path prefixed by /cygdrive for fixpath to work.
16154 new_path="$CYGWIN_ROOT_PATH$input_path"
16155 fi
16156 fi
16157
16158 # remove trailing .exe if any
16159 new_path="${new_path/%.exe/}"
16160
16161 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16162
16497 fi
16498
16499 # Call helper function which possibly converts this using DOS-style short mode.
16500 # If so, the updated path is stored in $new_path.
16501 new_path="$input_to_shortpath"
16502
16503 input_path="$input_to_shortpath"
16504 # Check if we need to convert this using DOS-style short mode. If the path
16505 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16506 # take no chances and rewrite it.
16507 # Note: m4 eats our [], so we need to use [ and ] instead.
16508 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16509 if test "x$has_forbidden_chars" != x; then
16510 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16511 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16512 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16513 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16514 # Going to short mode and back again did indeed matter. Since short mode is
16515 # case insensitive, let's make it lowercase to improve readability.
16516 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16517 # Now convert it back to Unix-stile (cygpath)
16518 input_path=`$CYGPATH -u "$shortmode_path"`
16519 new_path="$input_path"
16520 fi
16521 fi
16522
16523 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16524 if test "x$test_cygdrive_prefix" = x; then
16525 # As a simple fix, exclude /usr/bin since it's not a real path.
16526 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16527 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16528 # a path prefixed by /cygdrive for fixpath to work.
16529 new_path="$CYGWIN_ROOT_PATH$input_path"
16530 fi
16531 fi
16532
16533 # remove trailing .exe if any
16534 new_path="${new_path/%.exe/}"
16535
16536 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16537
16866 fi
16867
16868 # Call helper function which possibly converts this using DOS-style short mode.
16869 # If so, the updated path is stored in $new_path.
16870 new_path="$input_to_shortpath"
16871
16872 input_path="$input_to_shortpath"
16873 # Check if we need to convert this using DOS-style short mode. If the path
16874 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16875 # take no chances and rewrite it.
16876 # Note: m4 eats our [], so we need to use [ and ] instead.
16877 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16878 if test "x$has_forbidden_chars" != x; then
16879 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16880 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16881 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16882 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16883 # Going to short mode and back again did indeed matter. Since short mode is
16884 # case insensitive, let's make it lowercase to improve readability.
16885 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16886 # Now convert it back to Unix-stile (cygpath)
16887 input_path=`$CYGPATH -u "$shortmode_path"`
16888 new_path="$input_path"
16889 fi
16890 fi
16891
16892 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16893 if test "x$test_cygdrive_prefix" = x; then
16894 # As a simple fix, exclude /usr/bin since it's not a real path.
16895 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16896 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16897 # a path prefixed by /cygdrive for fixpath to work.
16898 new_path="$CYGWIN_ROOT_PATH$input_path"
16899 fi
16900 fi
16901
16902 # remove trailing .exe if any
16903 new_path="${new_path/%.exe/}"
16904
16905 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16906
19868 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
19869 fi
19870
19871 # Call helper function which possibly converts this using DOS-style short mode.
19872 # If so, the updated path is stored in $new_path.
19873
19874 input_path="$new_path"
19875 # Check if we need to convert this using DOS-style short mode. If the path
19876 # contains just simple characters, use it. Otherwise (spaces, weird characters),
19877 # take no chances and rewrite it.
19878 # Note: m4 eats our [], so we need to use [ and ] instead.
19879 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19880 if test "x$has_forbidden_chars" != x; then
19881 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19882 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19883 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19884 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19885 # Going to short mode and back again did indeed matter. Since short mode is
19886 # case insensitive, let's make it lowercase to improve readability.
19887 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19888 # Now convert it back to Unix-stile (cygpath)
19889 input_path=`$CYGPATH -u "$shortmode_path"`
19890 new_path="$input_path"
19891 fi
19892 fi
19893
19894 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19895 if test "x$test_cygdrive_prefix" = x; then
19896 # As a simple fix, exclude /usr/bin since it's not a real path.
19897 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
19898 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19899 # a path prefixed by /cygdrive for fixpath to work.
19900 new_path="$CYGWIN_ROOT_PATH$input_path"
19901 fi
19902 fi
19903
19904
19905 if test "x$path" != "x$new_path"; then
19906 BOOT_JDK="$new_path"
19907 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19908 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20200 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20201 fi
20202
20203 # Call helper function which possibly converts this using DOS-style short mode.
20204 # If so, the updated path is stored in $new_path.
20205
20206 input_path="$new_path"
20207 # Check if we need to convert this using DOS-style short mode. If the path
20208 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20209 # take no chances and rewrite it.
20210 # Note: m4 eats our [], so we need to use [ and ] instead.
20211 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20212 if test "x$has_forbidden_chars" != x; then
20213 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20214 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20215 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20216 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20217 # Going to short mode and back again did indeed matter. Since short mode is
20218 # case insensitive, let's make it lowercase to improve readability.
20219 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20220 # Now convert it back to Unix-stile (cygpath)
20221 input_path=`$CYGPATH -u "$shortmode_path"`
20222 new_path="$input_path"
20223 fi
20224 fi
20225
20226 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20227 if test "x$test_cygdrive_prefix" = x; then
20228 # As a simple fix, exclude /usr/bin since it's not a real path.
20229 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20230 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20231 # a path prefixed by /cygdrive for fixpath to work.
20232 new_path="$CYGWIN_ROOT_PATH$input_path"
20233 fi
20234 fi
20235
20236
20237 if test "x$path" != "x$new_path"; then
20238 BOOT_JDK="$new_path"
20239 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20240 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20346 as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
20347 fi
20348
20349 # Call helper function which possibly converts this using DOS-style short mode.
20350 # If so, the updated path is stored in $new_path.
20351
20352 input_path="$new_path"
20353 # Check if we need to convert this using DOS-style short mode. If the path
20354 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20355 # take no chances and rewrite it.
20356 # Note: m4 eats our [], so we need to use [ and ] instead.
20357 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20358 if test "x$has_forbidden_chars" != x; then
20359 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20360 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20361 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20362 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20363 # Going to short mode and back again did indeed matter. Since short mode is
20364 # case insensitive, let's make it lowercase to improve readability.
20365 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20366 # Now convert it back to Unix-stile (cygpath)
20367 input_path=`$CYGPATH -u "$shortmode_path"`
20368 new_path="$input_path"
20369 fi
20370 fi
20371
20372 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20373 if test "x$test_cygdrive_prefix" = x; then
20374 # As a simple fix, exclude /usr/bin since it's not a real path.
20375 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20376 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20377 # a path prefixed by /cygdrive for fixpath to work.
20378 new_path="$CYGWIN_ROOT_PATH$input_path"
20379 fi
20380 fi
20381
20382
20383 if test "x$path" != "x$new_path"; then
20384 JAVA_HOME_PROCESSED="$new_path"
20385 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
20386 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
20518 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20519 fi
20520
20521 # Call helper function which possibly converts this using DOS-style short mode.
20522 # If so, the updated path is stored in $new_path.
20523
20524 input_path="$new_path"
20525 # Check if we need to convert this using DOS-style short mode. If the path
20526 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20527 # take no chances and rewrite it.
20528 # Note: m4 eats our [], so we need to use [ and ] instead.
20529 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20530 if test "x$has_forbidden_chars" != x; then
20531 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20532 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20533 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20534 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20535 # Going to short mode and back again did indeed matter. Since short mode is
20536 # case insensitive, let's make it lowercase to improve readability.
20537 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20538 # Now convert it back to Unix-stile (cygpath)
20539 input_path=`$CYGPATH -u "$shortmode_path"`
20540 new_path="$input_path"
20541 fi
20542 fi
20543
20544 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20545 if test "x$test_cygdrive_prefix" = x; then
20546 # As a simple fix, exclude /usr/bin since it's not a real path.
20547 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20548 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20549 # a path prefixed by /cygdrive for fixpath to work.
20550 new_path="$CYGWIN_ROOT_PATH$input_path"
20551 fi
20552 fi
20553
20554
20555 if test "x$path" != "x$new_path"; then
20556 BOOT_JDK="$new_path"
20557 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20558 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20706 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20707 fi
20708
20709 # Call helper function which possibly converts this using DOS-style short mode.
20710 # If so, the updated path is stored in $new_path.
20711
20712 input_path="$new_path"
20713 # Check if we need to convert this using DOS-style short mode. If the path
20714 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20715 # take no chances and rewrite it.
20716 # Note: m4 eats our [], so we need to use [ and ] instead.
20717 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20718 if test "x$has_forbidden_chars" != x; then
20719 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20720 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20721 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20722 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20723 # Going to short mode and back again did indeed matter. Since short mode is
20724 # case insensitive, let's make it lowercase to improve readability.
20725 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20726 # Now convert it back to Unix-stile (cygpath)
20727 input_path=`$CYGPATH -u "$shortmode_path"`
20728 new_path="$input_path"
20729 fi
20730 fi
20731
20732 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20733 if test "x$test_cygdrive_prefix" = x; then
20734 # As a simple fix, exclude /usr/bin since it's not a real path.
20735 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20736 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20737 # a path prefixed by /cygdrive for fixpath to work.
20738 new_path="$CYGWIN_ROOT_PATH$input_path"
20739 fi
20740 fi
20741
20742
20743 if test "x$path" != "x$new_path"; then
20744 BOOT_JDK="$new_path"
20745 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20746 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21034 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21035 fi
21036
21037 # Call helper function which possibly converts this using DOS-style short mode.
21038 # If so, the updated path is stored in $new_path.
21039
21040 input_path="$new_path"
21041 # Check if we need to convert this using DOS-style short mode. If the path
21042 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21043 # take no chances and rewrite it.
21044 # Note: m4 eats our [], so we need to use [ and ] instead.
21045 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21046 if test "x$has_forbidden_chars" != x; then
21047 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21048 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21049 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21050 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21051 # Going to short mode and back again did indeed matter. Since short mode is
21052 # case insensitive, let's make it lowercase to improve readability.
21053 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21054 # Now convert it back to Unix-stile (cygpath)
21055 input_path=`$CYGPATH -u "$shortmode_path"`
21056 new_path="$input_path"
21057 fi
21058 fi
21059
21060 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21061 if test "x$test_cygdrive_prefix" = x; then
21062 # As a simple fix, exclude /usr/bin since it's not a real path.
21063 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21064 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21065 # a path prefixed by /cygdrive for fixpath to work.
21066 new_path="$CYGWIN_ROOT_PATH$input_path"
21067 fi
21068 fi
21069
21070
21071 if test "x$path" != "x$new_path"; then
21072 BOOT_JDK="$new_path"
21073 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21074 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21249 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21250 fi
21251
21252 # Call helper function which possibly converts this using DOS-style short mode.
21253 # If so, the updated path is stored in $new_path.
21254
21255 input_path="$new_path"
21256 # Check if we need to convert this using DOS-style short mode. If the path
21257 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21258 # take no chances and rewrite it.
21259 # Note: m4 eats our [], so we need to use [ and ] instead.
21260 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21261 if test "x$has_forbidden_chars" != x; then
21262 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21263 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21264 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21265 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21266 # Going to short mode and back again did indeed matter. Since short mode is
21267 # case insensitive, let's make it lowercase to improve readability.
21268 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21269 # Now convert it back to Unix-stile (cygpath)
21270 input_path=`$CYGPATH -u "$shortmode_path"`
21271 new_path="$input_path"
21272 fi
21273 fi
21274
21275 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21276 if test "x$test_cygdrive_prefix" = x; then
21277 # As a simple fix, exclude /usr/bin since it's not a real path.
21278 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21279 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21280 # a path prefixed by /cygdrive for fixpath to work.
21281 new_path="$CYGWIN_ROOT_PATH$input_path"
21282 fi
21283 fi
21284
21285
21286 if test "x$path" != "x$new_path"; then
21287 BOOT_JDK="$new_path"
21288 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21289 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21429 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21430 fi
21431
21432 # Call helper function which possibly converts this using DOS-style short mode.
21433 # If so, the updated path is stored in $new_path.
21434
21435 input_path="$new_path"
21436 # Check if we need to convert this using DOS-style short mode. If the path
21437 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21438 # take no chances and rewrite it.
21439 # Note: m4 eats our [], so we need to use [ and ] instead.
21440 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21441 if test "x$has_forbidden_chars" != x; then
21442 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21443 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21444 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21445 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21446 # Going to short mode and back again did indeed matter. Since short mode is
21447 # case insensitive, let's make it lowercase to improve readability.
21448 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21449 # Now convert it back to Unix-stile (cygpath)
21450 input_path=`$CYGPATH -u "$shortmode_path"`
21451 new_path="$input_path"
21452 fi
21453 fi
21454
21455 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21456 if test "x$test_cygdrive_prefix" = x; then
21457 # As a simple fix, exclude /usr/bin since it's not a real path.
21458 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21459 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21460 # a path prefixed by /cygdrive for fixpath to work.
21461 new_path="$CYGWIN_ROOT_PATH$input_path"
21462 fi
21463 fi
21464
21465
21466 if test "x$path" != "x$new_path"; then
21467 BOOT_JDK="$new_path"
21468 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21469 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21637 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21638 fi
21639
21640 # Call helper function which possibly converts this using DOS-style short mode.
21641 # If so, the updated path is stored in $new_path.
21642
21643 input_path="$new_path"
21644 # Check if we need to convert this using DOS-style short mode. If the path
21645 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21646 # take no chances and rewrite it.
21647 # Note: m4 eats our [], so we need to use [ and ] instead.
21648 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21649 if test "x$has_forbidden_chars" != x; then
21650 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21651 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21652 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21653 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21654 # Going to short mode and back again did indeed matter. Since short mode is
21655 # case insensitive, let's make it lowercase to improve readability.
21656 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21657 # Now convert it back to Unix-stile (cygpath)
21658 input_path=`$CYGPATH -u "$shortmode_path"`
21659 new_path="$input_path"
21660 fi
21661 fi
21662
21663 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21664 if test "x$test_cygdrive_prefix" = x; then
21665 # As a simple fix, exclude /usr/bin since it's not a real path.
21666 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21667 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21668 # a path prefixed by /cygdrive for fixpath to work.
21669 new_path="$CYGWIN_ROOT_PATH$input_path"
21670 fi
21671 fi
21672
21673
21674 if test "x$path" != "x$new_path"; then
21675 BOOT_JDK="$new_path"
21676 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21677 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21817 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21818 fi
21819
21820 # Call helper function which possibly converts this using DOS-style short mode.
21821 # If so, the updated path is stored in $new_path.
21822
21823 input_path="$new_path"
21824 # Check if we need to convert this using DOS-style short mode. If the path
21825 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21826 # take no chances and rewrite it.
21827 # Note: m4 eats our [], so we need to use [ and ] instead.
21828 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21829 if test "x$has_forbidden_chars" != x; then
21830 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21831 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21832 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21833 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21834 # Going to short mode and back again did indeed matter. Since short mode is
21835 # case insensitive, let's make it lowercase to improve readability.
21836 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21837 # Now convert it back to Unix-stile (cygpath)
21838 input_path=`$CYGPATH -u "$shortmode_path"`
21839 new_path="$input_path"
21840 fi
21841 fi
21842
21843 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21844 if test "x$test_cygdrive_prefix" = x; then
21845 # As a simple fix, exclude /usr/bin since it's not a real path.
21846 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21847 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21848 # a path prefixed by /cygdrive for fixpath to work.
21849 new_path="$CYGWIN_ROOT_PATH$input_path"
21850 fi
21851 fi
21852
21853
21854 if test "x$path" != "x$new_path"; then
21855 BOOT_JDK="$new_path"
21856 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21857 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22025 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22026 fi
22027
22028 # Call helper function which possibly converts this using DOS-style short mode.
22029 # If so, the updated path is stored in $new_path.
22030
22031 input_path="$new_path"
22032 # Check if we need to convert this using DOS-style short mode. If the path
22033 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22034 # take no chances and rewrite it.
22035 # Note: m4 eats our [], so we need to use [ and ] instead.
22036 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22037 if test "x$has_forbidden_chars" != x; then
22038 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22039 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22040 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22041 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22042 # Going to short mode and back again did indeed matter. Since short mode is
22043 # case insensitive, let's make it lowercase to improve readability.
22044 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22045 # Now convert it back to Unix-stile (cygpath)
22046 input_path=`$CYGPATH -u "$shortmode_path"`
22047 new_path="$input_path"
22048 fi
22049 fi
22050
22051 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22052 if test "x$test_cygdrive_prefix" = x; then
22053 # As a simple fix, exclude /usr/bin since it's not a real path.
22054 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22055 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22056 # a path prefixed by /cygdrive for fixpath to work.
22057 new_path="$CYGWIN_ROOT_PATH$input_path"
22058 fi
22059 fi
22060
22061
22062 if test "x$path" != "x$new_path"; then
22063 BOOT_JDK="$new_path"
22064 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22065 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22205 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22206 fi
22207
22208 # Call helper function which possibly converts this using DOS-style short mode.
22209 # If so, the updated path is stored in $new_path.
22210
22211 input_path="$new_path"
22212 # Check if we need to convert this using DOS-style short mode. If the path
22213 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22214 # take no chances and rewrite it.
22215 # Note: m4 eats our [], so we need to use [ and ] instead.
22216 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22217 if test "x$has_forbidden_chars" != x; then
22218 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22219 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22220 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22221 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22222 # Going to short mode and back again did indeed matter. Since short mode is
22223 # case insensitive, let's make it lowercase to improve readability.
22224 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22225 # Now convert it back to Unix-stile (cygpath)
22226 input_path=`$CYGPATH -u "$shortmode_path"`
22227 new_path="$input_path"
22228 fi
22229 fi
22230
22231 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22232 if test "x$test_cygdrive_prefix" = x; then
22233 # As a simple fix, exclude /usr/bin since it's not a real path.
22234 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22235 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22236 # a path prefixed by /cygdrive for fixpath to work.
22237 new_path="$CYGWIN_ROOT_PATH$input_path"
22238 fi
22239 fi
22240
22241
22242 if test "x$path" != "x$new_path"; then
22243 BOOT_JDK="$new_path"
22244 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22245 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22413 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22414 fi
22415
22416 # Call helper function which possibly converts this using DOS-style short mode.
22417 # If so, the updated path is stored in $new_path.
22418
22419 input_path="$new_path"
22420 # Check if we need to convert this using DOS-style short mode. If the path
22421 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22422 # take no chances and rewrite it.
22423 # Note: m4 eats our [], so we need to use [ and ] instead.
22424 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22425 if test "x$has_forbidden_chars" != x; then
22426 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22427 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22428 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22429 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22430 # Going to short mode and back again did indeed matter. Since short mode is
22431 # case insensitive, let's make it lowercase to improve readability.
22432 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22433 # Now convert it back to Unix-stile (cygpath)
22434 input_path=`$CYGPATH -u "$shortmode_path"`
22435 new_path="$input_path"
22436 fi
22437 fi
22438
22439 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22440 if test "x$test_cygdrive_prefix" = x; then
22441 # As a simple fix, exclude /usr/bin since it's not a real path.
22442 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22443 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22444 # a path prefixed by /cygdrive for fixpath to work.
22445 new_path="$CYGWIN_ROOT_PATH$input_path"
22446 fi
22447 fi
22448
22449
22450 if test "x$path" != "x$new_path"; then
22451 BOOT_JDK="$new_path"
22452 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22453 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22593 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22594 fi
22595
22596 # Call helper function which possibly converts this using DOS-style short mode.
22597 # If so, the updated path is stored in $new_path.
22598
22599 input_path="$new_path"
22600 # Check if we need to convert this using DOS-style short mode. If the path
22601 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22602 # take no chances and rewrite it.
22603 # Note: m4 eats our [], so we need to use [ and ] instead.
22604 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22605 if test "x$has_forbidden_chars" != x; then
22606 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22607 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22608 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22609 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22610 # Going to short mode and back again did indeed matter. Since short mode is
22611 # case insensitive, let's make it lowercase to improve readability.
22612 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22613 # Now convert it back to Unix-stile (cygpath)
22614 input_path=`$CYGPATH -u "$shortmode_path"`
22615 new_path="$input_path"
22616 fi
22617 fi
22618
22619 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22620 if test "x$test_cygdrive_prefix" = x; then
22621 # As a simple fix, exclude /usr/bin since it's not a real path.
22622 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22623 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22624 # a path prefixed by /cygdrive for fixpath to work.
22625 new_path="$CYGWIN_ROOT_PATH$input_path"
22626 fi
22627 fi
22628
22629
22630 if test "x$path" != "x$new_path"; then
22631 BOOT_JDK="$new_path"
22632 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22633 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22788 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22789 fi
22790
22791 # Call helper function which possibly converts this using DOS-style short mode.
22792 # If so, the updated path is stored in $new_path.
22793
22794 input_path="$new_path"
22795 # Check if we need to convert this using DOS-style short mode. If the path
22796 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22797 # take no chances and rewrite it.
22798 # Note: m4 eats our [], so we need to use [ and ] instead.
22799 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22800 if test "x$has_forbidden_chars" != x; then
22801 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22802 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22803 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22804 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22805 # Going to short mode and back again did indeed matter. Since short mode is
22806 # case insensitive, let's make it lowercase to improve readability.
22807 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22808 # Now convert it back to Unix-stile (cygpath)
22809 input_path=`$CYGPATH -u "$shortmode_path"`
22810 new_path="$input_path"
22811 fi
22812 fi
22813
22814 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22815 if test "x$test_cygdrive_prefix" = x; then
22816 # As a simple fix, exclude /usr/bin since it's not a real path.
22817 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22818 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22819 # a path prefixed by /cygdrive for fixpath to work.
22820 new_path="$CYGWIN_ROOT_PATH$input_path"
22821 fi
22822 fi
22823
22824
22825 if test "x$path" != "x$new_path"; then
22826 BOOT_JDK="$new_path"
22827 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22828 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22966 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22967 fi
22968
22969 # Call helper function which possibly converts this using DOS-style short mode.
22970 # If so, the updated path is stored in $new_path.
22971
22972 input_path="$new_path"
22973 # Check if we need to convert this using DOS-style short mode. If the path
22974 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22975 # take no chances and rewrite it.
22976 # Note: m4 eats our [], so we need to use [ and ] instead.
22977 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22978 if test "x$has_forbidden_chars" != x; then
22979 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22980 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22981 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22982 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22983 # Going to short mode and back again did indeed matter. Since short mode is
22984 # case insensitive, let's make it lowercase to improve readability.
22985 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22986 # Now convert it back to Unix-stile (cygpath)
22987 input_path=`$CYGPATH -u "$shortmode_path"`
22988 new_path="$input_path"
22989 fi
22990 fi
22991
22992 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22993 if test "x$test_cygdrive_prefix" = x; then
22994 # As a simple fix, exclude /usr/bin since it's not a real path.
22995 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22996 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22997 # a path prefixed by /cygdrive for fixpath to work.
22998 new_path="$CYGWIN_ROOT_PATH$input_path"
22999 fi
23000 fi
23001
23002
23003 if test "x$path" != "x$new_path"; then
23004 BOOT_JDK="$new_path"
23005 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23006 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23162 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23163 fi
23164
23165 # Call helper function which possibly converts this using DOS-style short mode.
23166 # If so, the updated path is stored in $new_path.
23167
23168 input_path="$new_path"
23169 # Check if we need to convert this using DOS-style short mode. If the path
23170 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23171 # take no chances and rewrite it.
23172 # Note: m4 eats our [], so we need to use [ and ] instead.
23173 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23174 if test "x$has_forbidden_chars" != x; then
23175 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23176 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23177 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23178 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23179 # Going to short mode and back again did indeed matter. Since short mode is
23180 # case insensitive, let's make it lowercase to improve readability.
23181 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23182 # Now convert it back to Unix-stile (cygpath)
23183 input_path=`$CYGPATH -u "$shortmode_path"`
23184 new_path="$input_path"
23185 fi
23186 fi
23187
23188 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23189 if test "x$test_cygdrive_prefix" = x; then
23190 # As a simple fix, exclude /usr/bin since it's not a real path.
23191 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23192 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23193 # a path prefixed by /cygdrive for fixpath to work.
23194 new_path="$CYGWIN_ROOT_PATH$input_path"
23195 fi
23196 fi
23197
23198
23199 if test "x$path" != "x$new_path"; then
23200 BOOT_JDK="$new_path"
23201 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23202 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23340 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23341 fi
23342
23343 # Call helper function which possibly converts this using DOS-style short mode.
23344 # If so, the updated path is stored in $new_path.
23345
23346 input_path="$new_path"
23347 # Check if we need to convert this using DOS-style short mode. If the path
23348 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23349 # take no chances and rewrite it.
23350 # Note: m4 eats our [], so we need to use [ and ] instead.
23351 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23352 if test "x$has_forbidden_chars" != x; then
23353 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23354 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23355 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23356 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23357 # Going to short mode and back again did indeed matter. Since short mode is
23358 # case insensitive, let's make it lowercase to improve readability.
23359 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23360 # Now convert it back to Unix-stile (cygpath)
23361 input_path=`$CYGPATH -u "$shortmode_path"`
23362 new_path="$input_path"
23363 fi
23364 fi
23365
23366 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23367 if test "x$test_cygdrive_prefix" = x; then
23368 # As a simple fix, exclude /usr/bin since it's not a real path.
23369 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23370 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23371 # a path prefixed by /cygdrive for fixpath to work.
23372 new_path="$CYGWIN_ROOT_PATH$input_path"
23373 fi
23374 fi
23375
23376
23377 if test "x$path" != "x$new_path"; then
23378 BOOT_JDK="$new_path"
23379 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23380 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23535 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23536 fi
23537
23538 # Call helper function which possibly converts this using DOS-style short mode.
23539 # If so, the updated path is stored in $new_path.
23540
23541 input_path="$new_path"
23542 # Check if we need to convert this using DOS-style short mode. If the path
23543 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23544 # take no chances and rewrite it.
23545 # Note: m4 eats our [], so we need to use [ and ] instead.
23546 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23547 if test "x$has_forbidden_chars" != x; then
23548 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23549 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23550 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23551 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23552 # Going to short mode and back again did indeed matter. Since short mode is
23553 # case insensitive, let's make it lowercase to improve readability.
23554 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23555 # Now convert it back to Unix-stile (cygpath)
23556 input_path=`$CYGPATH -u "$shortmode_path"`
23557 new_path="$input_path"
23558 fi
23559 fi
23560
23561 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23562 if test "x$test_cygdrive_prefix" = x; then
23563 # As a simple fix, exclude /usr/bin since it's not a real path.
23564 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23565 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23566 # a path prefixed by /cygdrive for fixpath to work.
23567 new_path="$CYGWIN_ROOT_PATH$input_path"
23568 fi
23569 fi
23570
23571
23572 if test "x$path" != "x$new_path"; then
23573 BOOT_JDK="$new_path"
23574 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23575 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23713 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23714 fi
23715
23716 # Call helper function which possibly converts this using DOS-style short mode.
23717 # If so, the updated path is stored in $new_path.
23718
23719 input_path="$new_path"
23720 # Check if we need to convert this using DOS-style short mode. If the path
23721 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23722 # take no chances and rewrite it.
23723 # Note: m4 eats our [], so we need to use [ and ] instead.
23724 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23725 if test "x$has_forbidden_chars" != x; then
23726 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23727 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23728 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23729 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23730 # Going to short mode and back again did indeed matter. Since short mode is
23731 # case insensitive, let's make it lowercase to improve readability.
23732 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23733 # Now convert it back to Unix-stile (cygpath)
23734 input_path=`$CYGPATH -u "$shortmode_path"`
23735 new_path="$input_path"
23736 fi
23737 fi
23738
23739 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23740 if test "x$test_cygdrive_prefix" = x; then
23741 # As a simple fix, exclude /usr/bin since it's not a real path.
23742 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23743 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23744 # a path prefixed by /cygdrive for fixpath to work.
23745 new_path="$CYGWIN_ROOT_PATH$input_path"
23746 fi
23747 fi
23748
23749
23750 if test "x$path" != "x$new_path"; then
23751 BOOT_JDK="$new_path"
23752 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23753 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23909 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23910 fi
23911
23912 # Call helper function which possibly converts this using DOS-style short mode.
23913 # If so, the updated path is stored in $new_path.
23914
23915 input_path="$new_path"
23916 # Check if we need to convert this using DOS-style short mode. If the path
23917 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23918 # take no chances and rewrite it.
23919 # Note: m4 eats our [], so we need to use [ and ] instead.
23920 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23921 if test "x$has_forbidden_chars" != x; then
23922 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23923 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23924 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23925 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23926 # Going to short mode and back again did indeed matter. Since short mode is
23927 # case insensitive, let's make it lowercase to improve readability.
23928 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23929 # Now convert it back to Unix-stile (cygpath)
23930 input_path=`$CYGPATH -u "$shortmode_path"`
23931 new_path="$input_path"
23932 fi
23933 fi
23934
23935 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23936 if test "x$test_cygdrive_prefix" = x; then
23937 # As a simple fix, exclude /usr/bin since it's not a real path.
23938 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23939 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23940 # a path prefixed by /cygdrive for fixpath to work.
23941 new_path="$CYGWIN_ROOT_PATH$input_path"
23942 fi
23943 fi
23944
23945
23946 if test "x$path" != "x$new_path"; then
23947 BOOT_JDK="$new_path"
23948 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23949 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24087 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24088 fi
24089
24090 # Call helper function which possibly converts this using DOS-style short mode.
24091 # If so, the updated path is stored in $new_path.
24092
24093 input_path="$new_path"
24094 # Check if we need to convert this using DOS-style short mode. If the path
24095 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24096 # take no chances and rewrite it.
24097 # Note: m4 eats our [], so we need to use [ and ] instead.
24098 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24099 if test "x$has_forbidden_chars" != x; then
24100 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24101 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24102 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24103 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24104 # Going to short mode and back again did indeed matter. Since short mode is
24105 # case insensitive, let's make it lowercase to improve readability.
24106 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24107 # Now convert it back to Unix-stile (cygpath)
24108 input_path=`$CYGPATH -u "$shortmode_path"`
24109 new_path="$input_path"
24110 fi
24111 fi
24112
24113 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24114 if test "x$test_cygdrive_prefix" = x; then
24115 # As a simple fix, exclude /usr/bin since it's not a real path.
24116 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24117 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24118 # a path prefixed by /cygdrive for fixpath to work.
24119 new_path="$CYGWIN_ROOT_PATH$input_path"
24120 fi
24121 fi
24122
24123
24124 if test "x$path" != "x$new_path"; then
24125 BOOT_JDK="$new_path"
24126 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24127 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24264 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24265 fi
24266
24267 # Call helper function which possibly converts this using DOS-style short mode.
24268 # If so, the updated path is stored in $new_path.
24269
24270 input_path="$new_path"
24271 # Check if we need to convert this using DOS-style short mode. If the path
24272 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24273 # take no chances and rewrite it.
24274 # Note: m4 eats our [], so we need to use [ and ] instead.
24275 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24276 if test "x$has_forbidden_chars" != x; then
24277 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24278 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24279 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24280 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24281 # Going to short mode and back again did indeed matter. Since short mode is
24282 # case insensitive, let's make it lowercase to improve readability.
24283 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24284 # Now convert it back to Unix-stile (cygpath)
24285 input_path=`$CYGPATH -u "$shortmode_path"`
24286 new_path="$input_path"
24287 fi
24288 fi
24289
24290 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24291 if test "x$test_cygdrive_prefix" = x; then
24292 # As a simple fix, exclude /usr/bin since it's not a real path.
24293 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24294 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24295 # a path prefixed by /cygdrive for fixpath to work.
24296 new_path="$CYGWIN_ROOT_PATH$input_path"
24297 fi
24298 fi
24299
24300
24301 if test "x$path" != "x$new_path"; then
24302 BOOT_JDK="$new_path"
24303 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24304 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25194 { $as_echo "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
25195 $as_echo "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
25196 fi
25197
25198
25199 # Then detect the actual binaries needed
25200
25201 # FIXME: Is this needed?
25202 ac_ext=cpp
25203 ac_cpp='$CXXCPP $CPPFLAGS'
25204 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
25205 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
25206 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
25207
25208
25209 # Store the CFLAGS etal passed to the configure script.
25210 ORG_CFLAGS="$CFLAGS"
25211 ORG_CXXFLAGS="$CXXFLAGS"
25212 ORG_OBJCFLAGS="$OBJCFLAGS"
25213
25214 # On Windows, we need to detect the visual studio installation first.
25215 # This will change the PATH, but we need to keep that new PATH even
25216 # after toolchain detection is done, since the compiler (on x86) uses
25217 # it for DLL resolution in runtime.
25218 if test "x$OPENJDK_BUILD_OS" = "xwindows" && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then
25219
25220 # Store path to cygwin link.exe to help excluding it when searching for
25221 # VS linker. This must be done before changing the PATH when looking for VS.
25222 # Extract the first word of "link", so it can be a program name with args.
25223 set dummy link; ac_word=$2
25224 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
25225 $as_echo_n "checking for $ac_word... " >&6; }
25226 if ${ac_cv_path_CYGWIN_LINK+:} false; then :
25227 $as_echo_n "(cached) " >&6
25228 else
25229 case $CYGWIN_LINK in
25230 [\\/]* | ?:[\\/]*)
25231 ac_cv_path_CYGWIN_LINK="$CYGWIN_LINK" # Let the user override the test with a path.
25232 ;;
25233 *)
25234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
25235 for as_dir in $PATH
25236 do
25237 IFS=$as_save_IFS
25238 test -z "$as_dir" && as_dir=.
25276
25277 # First-hand choice is to locate and run the vsvars bat file.
25278
25279
25280 # Check whether --with-toolchain-version was given.
25281 if test "${with_toolchain_version+set}" = set; then :
25282 withval=$with_toolchain_version;
25283 fi
25284
25285
25286 if test "x$with_toolchain_version" = xlist; then
25287 # List all toolchains
25288 { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
25289 $as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
25290 for version in $VALID_VS_VERSIONS; do
25291 eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
25292 $PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION"
25293 done
25294
25295 exit 0
25296 elif test "x$with_toolchain_version" != x; then
25297 # User override; check that it is valid
25298 if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
25299 { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
25300 $as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
25301 { $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
25302 $as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
25303 as_fn_error $? "Cannot continue." "$LINENO" 5
25304 fi
25305 VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
25306 else
25307 # No flag given, use default
25308 VS_VERSIONS_PROBE_LIST="$VALID_VS_VERSIONS"
25309 fi
25310
25311 for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do
25312
25313 VS_VERSION="$VS_VERSION"
25314 eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}"
25315 eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}"
25848 fi
25849 fi
25850 fi
25851
25852 fi
25853
25854 if test "x$VS_ENV_CMD" != x; then
25855 TOOLCHAIN_VERSION=$VS_VERSION
25856 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
25857 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
25858 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
25859 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
25860 # The rest of the variables are already evaled while probing
25861 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
25862 $as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
25863 break
25864 fi
25865 done
25866
25867
25868 if test "x$VS_ENV_CMD" != x; then
25869 # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
25870
25871 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25872
25873 # First separate the path from the arguments. This will split at the first
25874 # space.
25875 complete="$VS_ENV_CMD"
25876 path="${complete%% *}"
25877 tmp="$complete EOL"
25878 arguments="${tmp#* }"
25879
25880 # Input might be given as Windows format, start by converting to
25881 # unix format.
25882 new_path=`$CYGPATH -u "$path"`
25883
25884 # Now try to locate executable using which
25885 new_path=`$WHICH "$new_path" 2> /dev/null`
25886 # bat and cmd files are not always considered executable in cygwin causing which
25887 # to not find them
25946 fi
25947
25948 # Call helper function which possibly converts this using DOS-style short mode.
25949 # If so, the updated path is stored in $new_path.
25950 new_path="$input_to_shortpath"
25951
25952 input_path="$input_to_shortpath"
25953 # Check if we need to convert this using DOS-style short mode. If the path
25954 # contains just simple characters, use it. Otherwise (spaces, weird characters),
25955 # take no chances and rewrite it.
25956 # Note: m4 eats our [], so we need to use [ and ] instead.
25957 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
25958 if test "x$has_forbidden_chars" != x; then
25959 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
25960 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
25961 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
25962 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
25963 # Going to short mode and back again did indeed matter. Since short mode is
25964 # case insensitive, let's make it lowercase to improve readability.
25965 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
25966 # Now convert it back to Unix-stile (cygpath)
25967 input_path=`$CYGPATH -u "$shortmode_path"`
25968 new_path="$input_path"
25969 fi
25970 fi
25971
25972 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
25973 if test "x$test_cygdrive_prefix" = x; then
25974 # As a simple fix, exclude /usr/bin since it's not a real path.
25975 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
25976 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
25977 # a path prefixed by /cygdrive for fixpath to work.
25978 new_path="$CYGWIN_ROOT_PATH$input_path"
25979 fi
25980 fi
25981
25982 # remove trailing .exe if any
25983 new_path="${new_path/%.exe/}"
25984
25985 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25986
26177 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26178 windows_path=`$CYGPATH -m "$unix_path"`
26179 WINPATH_BASH="$windows_path"
26180 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26181 windows_path=`cmd //c echo $unix_path`
26182 WINPATH_BASH="$windows_path"
26183 fi
26184
26185
26186 # Generate a DOS batch file which runs $VS_ENV_CMD, and then creates a shell
26187 # script (executable by bash) that will setup the important variables.
26188 EXTRACT_VC_ENV_BAT_FILE="$VS_ENV_TMP_DIR/extract-vs-env.bat"
26189 $ECHO "@echo off" > $EXTRACT_VC_ENV_BAT_FILE
26190 # This will end up something like:
26191 # call C:/progra~2/micros~2.0/vc/bin/amd64/vcvars64.bat
26192 $ECHO "call $WINPATH_VS_ENV_CMD $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE
26193 # These will end up something like:
26194 # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh
26195 # The trailing space for everyone except PATH is no typo, but is needed due
26196 # to trailing \ in the Windows paths. These will be stripped later.
26197 $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE
26198 $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE
26199 $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE
26200 $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE
26201 $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE
26202 $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' >> $EXTRACT_VC_ENV_BAT_FILE
26203
26204 # Now execute the newly created bat file.
26205 # The | cat is to stop SetEnv.Cmd to mess with system colors on msys.
26206 # Change directory so we don't need to mess with Windows paths in redirects.
26207 cd $VS_ENV_TMP_DIR
26208 cmd /c extract-vs-env.bat | $CAT
26209 cd $CURDIR
26210
26211 if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
26212 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
26213 $as_echo "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
26214 { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
26215 $as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
26216 { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
26217 $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
26218 as_fn_error $? "Cannot continue" "$LINENO" 5
26219 fi
26220
26221 # Now set all paths and other env variables. This will allow the rest of
26222 # the configure script to find and run the compiler in the proper way.
26223 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
26224 $as_echo "$as_me: Setting extracted environment variables" >&6;}
26225 . $VS_ENV_TMP_DIR/set-vs-env.sh
26226 # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
26227 # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
26228 else
26229 # We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
26230 { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
26231 $as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
26232 fi
26233
26234 # At this point, we should have correct variables in the environment, or we can't continue.
26235 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
26236 $as_echo_n "checking for Visual Studio variables... " >&6; }
26237
26238 if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x || test "x$WINDOWSSDKDIR" != x; then
26239 if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
26240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
26241 $as_echo "present but broken" >&6; }
26242 as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5
26243 else
26244 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
26245 $as_echo "ok" >&6; }
26246 # Remove any trailing "\" and " " from the variables.
26247 VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED 's/\\\\* *$//'`
26248 VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\* *$//'`
26249 VCINSTALLDIR=`$ECHO "$VCINSTALLDIR" | $SED 's/\\\\* *$//'`
26250 WindowsSDKDir=`$ECHO "$WindowsSDKDir" | $SED 's/\\\\* *$//'`
26251 WINDOWSSDKDIR=`$ECHO "$WINDOWSSDKDIR" | $SED 's/\\\\* *$//'`
26252 # Remove any paths containing # (typically F#) as that messes up make. This
26253 # is needed if visual studio was installed with F# support.
26254 VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[^:#]*#[^:]*://g'`
26255
26256
26257
26258
26268 $as_echo "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
26269 else
26270 { $as_echo "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
26271 $as_echo "$as_me: Running the extraction script failed." >&6;}
26272 fi
26273 { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
26274 $as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
26275 { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
26276 $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
26277 as_fn_error $? "Cannot continue" "$LINENO" 5
26278 fi
26279
26280 # Reset path to VS_PATH. It will include everything that was on PATH at the time we
26281 # ran TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV.
26282 PATH="$VS_PATH"
26283 # The microsoft toolchain also requires INCLUDE and LIB to be set.
26284 export INCLUDE="$VS_INCLUDE"
26285 export LIB="$VS_LIB"
26286 fi
26287
26288 # autoconf magic only relies on PATH, so update it if tools dir is specified
26289 OLD_PATH="$PATH"
26290
26291 # Before we locate the compilers, we need to sanitize the Xcode build environment
26292 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
26293 # determine path to Xcode developer directory
26294 # can be empty in which case all the tools will rely on a sane Xcode 4 installation
26295 SET_DEVELOPER_DIR=
26296
26297 if test -n "$XCODE_PATH"; then
26298 DEVELOPER_DIR="$XCODE_PATH"/Contents/Developer
26299 fi
26300
26301 # DEVELOPER_DIR could also be provided directly
26302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Determining if we need to set DEVELOPER_DIR" >&5
26303 $as_echo_n "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
26304 if test -n "$DEVELOPER_DIR"; then
26305 if test ! -d "$DEVELOPER_DIR"; then
26306 as_fn_error $? "Xcode Developer path does not exist: $DEVELOPER_DIR, please provide a path to the Xcode 4 application bundle using --with-xcode-path" "$LINENO" 5
26307 fi
26308 if test ! -f "$DEVELOPER_DIR"/usr/bin/xcodebuild; then
26309 as_fn_error $? "Xcode Developer path is not valid: $DEVELOPER_DIR, it must point to Contents/Developer inside an Xcode application bundle" "$LINENO" 5
26310 fi
26733 fi
26734
26735 # Call helper function which possibly converts this using DOS-style short mode.
26736 # If so, the updated path is stored in $new_path.
26737 new_path="$input_to_shortpath"
26738
26739 input_path="$input_to_shortpath"
26740 # Check if we need to convert this using DOS-style short mode. If the path
26741 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26742 # take no chances and rewrite it.
26743 # Note: m4 eats our [], so we need to use [ and ] instead.
26744 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26745 if test "x$has_forbidden_chars" != x; then
26746 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26747 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26748 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26749 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26750 # Going to short mode and back again did indeed matter. Since short mode is
26751 # case insensitive, let's make it lowercase to improve readability.
26752 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26753 # Now convert it back to Unix-stile (cygpath)
26754 input_path=`$CYGPATH -u "$shortmode_path"`
26755 new_path="$input_path"
26756 fi
26757 fi
26758
26759 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26760 if test "x$test_cygdrive_prefix" = x; then
26761 # As a simple fix, exclude /usr/bin since it's not a real path.
26762 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
26763 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26764 # a path prefixed by /cygdrive for fixpath to work.
26765 new_path="$CYGWIN_ROOT_PATH$input_path"
26766 fi
26767 fi
26768
26769 # remove trailing .exe if any
26770 new_path="${new_path/%.exe/}"
26771
26772 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26773
27190 fi
27191
27192 # Call helper function which possibly converts this using DOS-style short mode.
27193 # If so, the updated path is stored in $new_path.
27194 new_path="$input_to_shortpath"
27195
27196 input_path="$input_to_shortpath"
27197 # Check if we need to convert this using DOS-style short mode. If the path
27198 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27199 # take no chances and rewrite it.
27200 # Note: m4 eats our [], so we need to use [ and ] instead.
27201 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27202 if test "x$has_forbidden_chars" != x; then
27203 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27204 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27205 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27206 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27207 # Going to short mode and back again did indeed matter. Since short mode is
27208 # case insensitive, let's make it lowercase to improve readability.
27209 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27210 # Now convert it back to Unix-stile (cygpath)
27211 input_path=`$CYGPATH -u "$shortmode_path"`
27212 new_path="$input_path"
27213 fi
27214 fi
27215
27216 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27217 if test "x$test_cygdrive_prefix" = x; then
27218 # As a simple fix, exclude /usr/bin since it's not a real path.
27219 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
27220 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27221 # a path prefixed by /cygdrive for fixpath to work.
27222 new_path="$CYGWIN_ROOT_PATH$input_path"
27223 fi
27224 fi
27225
27226 # remove trailing .exe if any
27227 new_path="${new_path/%.exe/}"
27228
27229 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27230
28475 fi
28476
28477 # Call helper function which possibly converts this using DOS-style short mode.
28478 # If so, the updated path is stored in $new_path.
28479 new_path="$input_to_shortpath"
28480
28481 input_path="$input_to_shortpath"
28482 # Check if we need to convert this using DOS-style short mode. If the path
28483 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28484 # take no chances and rewrite it.
28485 # Note: m4 eats our [], so we need to use [ and ] instead.
28486 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28487 if test "x$has_forbidden_chars" != x; then
28488 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28489 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28490 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28491 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28492 # Going to short mode and back again did indeed matter. Since short mode is
28493 # case insensitive, let's make it lowercase to improve readability.
28494 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28495 # Now convert it back to Unix-stile (cygpath)
28496 input_path=`$CYGPATH -u "$shortmode_path"`
28497 new_path="$input_path"
28498 fi
28499 fi
28500
28501 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28502 if test "x$test_cygdrive_prefix" = x; then
28503 # As a simple fix, exclude /usr/bin since it's not a real path.
28504 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
28505 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28506 # a path prefixed by /cygdrive for fixpath to work.
28507 new_path="$CYGWIN_ROOT_PATH$input_path"
28508 fi
28509 fi
28510
28511 # remove trailing .exe if any
28512 new_path="${new_path/%.exe/}"
28513
28514 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28515
28932 fi
28933
28934 # Call helper function which possibly converts this using DOS-style short mode.
28935 # If so, the updated path is stored in $new_path.
28936 new_path="$input_to_shortpath"
28937
28938 input_path="$input_to_shortpath"
28939 # Check if we need to convert this using DOS-style short mode. If the path
28940 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28941 # take no chances and rewrite it.
28942 # Note: m4 eats our [], so we need to use [ and ] instead.
28943 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28944 if test "x$has_forbidden_chars" != x; then
28945 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28946 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28947 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28948 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28949 # Going to short mode and back again did indeed matter. Since short mode is
28950 # case insensitive, let's make it lowercase to improve readability.
28951 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28952 # Now convert it back to Unix-stile (cygpath)
28953 input_path=`$CYGPATH -u "$shortmode_path"`
28954 new_path="$input_path"
28955 fi
28956 fi
28957
28958 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28959 if test "x$test_cygdrive_prefix" = x; then
28960 # As a simple fix, exclude /usr/bin since it's not a real path.
28961 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
28962 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28963 # a path prefixed by /cygdrive for fixpath to work.
28964 new_path="$CYGWIN_ROOT_PATH$input_path"
28965 fi
28966 fi
28967
28968 # remove trailing .exe if any
28969 new_path="${new_path/%.exe/}"
28970
28971 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28972
29822 fi
29823
29824 # Call helper function which possibly converts this using DOS-style short mode.
29825 # If so, the updated path is stored in $new_path.
29826 new_path="$input_to_shortpath"
29827
29828 input_path="$input_to_shortpath"
29829 # Check if we need to convert this using DOS-style short mode. If the path
29830 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29831 # take no chances and rewrite it.
29832 # Note: m4 eats our [], so we need to use [ and ] instead.
29833 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29834 if test "x$has_forbidden_chars" != x; then
29835 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29836 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29837 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29838 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29839 # Going to short mode and back again did indeed matter. Since short mode is
29840 # case insensitive, let's make it lowercase to improve readability.
29841 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29842 # Now convert it back to Unix-stile (cygpath)
29843 input_path=`$CYGPATH -u "$shortmode_path"`
29844 new_path="$input_path"
29845 fi
29846 fi
29847
29848 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29849 if test "x$test_cygdrive_prefix" = x; then
29850 # As a simple fix, exclude /usr/bin since it's not a real path.
29851 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
29852 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29853 # a path prefixed by /cygdrive for fixpath to work.
29854 new_path="$CYGWIN_ROOT_PATH$input_path"
29855 fi
29856 fi
29857
29858 # remove trailing .exe if any
29859 new_path="${new_path/%.exe/}"
29860
29861 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29862
30237 fi
30238
30239 # Call helper function which possibly converts this using DOS-style short mode.
30240 # If so, the updated path is stored in $new_path.
30241 new_path="$input_to_shortpath"
30242
30243 input_path="$input_to_shortpath"
30244 # Check if we need to convert this using DOS-style short mode. If the path
30245 # contains just simple characters, use it. Otherwise (spaces, weird characters),
30246 # take no chances and rewrite it.
30247 # Note: m4 eats our [], so we need to use [ and ] instead.
30248 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
30249 if test "x$has_forbidden_chars" != x; then
30250 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
30251 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
30252 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
30253 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
30254 # Going to short mode and back again did indeed matter. Since short mode is
30255 # case insensitive, let's make it lowercase to improve readability.
30256 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
30257 # Now convert it back to Unix-stile (cygpath)
30258 input_path=`$CYGPATH -u "$shortmode_path"`
30259 new_path="$input_path"
30260 fi
30261 fi
30262
30263 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
30264 if test "x$test_cygdrive_prefix" = x; then
30265 # As a simple fix, exclude /usr/bin since it's not a real path.
30266 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
30267 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
30268 # a path prefixed by /cygdrive for fixpath to work.
30269 new_path="$CYGWIN_ROOT_PATH$input_path"
30270 fi
30271 fi
30272
30273 # remove trailing .exe if any
30274 new_path="${new_path/%.exe/}"
30275
30276 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30277
30581 fi
30582
30583 # Call helper function which possibly converts this using DOS-style short mode.
30584 # If so, the updated path is stored in $new_path.
30585 new_path="$input_to_shortpath"
30586
30587 input_path="$input_to_shortpath"
30588 # Check if we need to convert this using DOS-style short mode. If the path
30589 # contains just simple characters, use it. Otherwise (spaces, weird characters),
30590 # take no chances and rewrite it.
30591 # Note: m4 eats our [], so we need to use [ and ] instead.
30592 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
30593 if test "x$has_forbidden_chars" != x; then
30594 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
30595 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
30596 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
30597 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
30598 # Going to short mode and back again did indeed matter. Since short mode is
30599 # case insensitive, let's make it lowercase to improve readability.
30600 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
30601 # Now convert it back to Unix-stile (cygpath)
30602 input_path=`$CYGPATH -u "$shortmode_path"`
30603 new_path="$input_path"
30604 fi
30605 fi
30606
30607 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
30608 if test "x$test_cygdrive_prefix" = x; then
30609 # As a simple fix, exclude /usr/bin since it's not a real path.
30610 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
30611 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
30612 # a path prefixed by /cygdrive for fixpath to work.
30613 new_path="$CYGWIN_ROOT_PATH$input_path"
30614 fi
30615 fi
30616
30617 # remove trailing .exe if any
30618 new_path="${new_path/%.exe/}"
30619
30620 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30621
31076 fi
31077
31078 # Call helper function which possibly converts this using DOS-style short mode.
31079 # If so, the updated path is stored in $new_path.
31080 new_path="$input_to_shortpath"
31081
31082 input_path="$input_to_shortpath"
31083 # Check if we need to convert this using DOS-style short mode. If the path
31084 # contains just simple characters, use it. Otherwise (spaces, weird characters),
31085 # take no chances and rewrite it.
31086 # Note: m4 eats our [], so we need to use [ and ] instead.
31087 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
31088 if test "x$has_forbidden_chars" != x; then
31089 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
31090 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
31091 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
31092 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
31093 # Going to short mode and back again did indeed matter. Since short mode is
31094 # case insensitive, let's make it lowercase to improve readability.
31095 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
31096 # Now convert it back to Unix-stile (cygpath)
31097 input_path=`$CYGPATH -u "$shortmode_path"`
31098 new_path="$input_path"
31099 fi
31100 fi
31101
31102 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
31103 if test "x$test_cygdrive_prefix" = x; then
31104 # As a simple fix, exclude /usr/bin since it's not a real path.
31105 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
31106 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
31107 # a path prefixed by /cygdrive for fixpath to work.
31108 new_path="$CYGWIN_ROOT_PATH$input_path"
31109 fi
31110 fi
31111
31112 # remove trailing .exe if any
31113 new_path="${new_path/%.exe/}"
31114
31115 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31116
31704 fi
31705
31706 # Call helper function which possibly converts this using DOS-style short mode.
31707 # If so, the updated path is stored in $new_path.
31708 new_path="$input_to_shortpath"
31709
31710 input_path="$input_to_shortpath"
31711 # Check if we need to convert this using DOS-style short mode. If the path
31712 # contains just simple characters, use it. Otherwise (spaces, weird characters),
31713 # take no chances and rewrite it.
31714 # Note: m4 eats our [], so we need to use [ and ] instead.
31715 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
31716 if test "x$has_forbidden_chars" != x; then
31717 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
31718 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
31719 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
31720 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
31721 # Going to short mode and back again did indeed matter. Since short mode is
31722 # case insensitive, let's make it lowercase to improve readability.
31723 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
31724 # Now convert it back to Unix-stile (cygpath)
31725 input_path=`$CYGPATH -u "$shortmode_path"`
31726 new_path="$input_path"
31727 fi
31728 fi
31729
31730 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
31731 if test "x$test_cygdrive_prefix" = x; then
31732 # As a simple fix, exclude /usr/bin since it's not a real path.
31733 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
31734 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
31735 # a path prefixed by /cygdrive for fixpath to work.
31736 new_path="$CYGWIN_ROOT_PATH$input_path"
31737 fi
31738 fi
31739
31740 # remove trailing .exe if any
31741 new_path="${new_path/%.exe/}"
31742
31743 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31744
32240 fi
32241
32242 # Call helper function which possibly converts this using DOS-style short mode.
32243 # If so, the updated path is stored in $new_path.
32244 new_path="$input_to_shortpath"
32245
32246 input_path="$input_to_shortpath"
32247 # Check if we need to convert this using DOS-style short mode. If the path
32248 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32249 # take no chances and rewrite it.
32250 # Note: m4 eats our [], so we need to use [ and ] instead.
32251 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32252 if test "x$has_forbidden_chars" != x; then
32253 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32254 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32255 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32256 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32257 # Going to short mode and back again did indeed matter. Since short mode is
32258 # case insensitive, let's make it lowercase to improve readability.
32259 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32260 # Now convert it back to Unix-stile (cygpath)
32261 input_path=`$CYGPATH -u "$shortmode_path"`
32262 new_path="$input_path"
32263 fi
32264 fi
32265
32266 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32267 if test "x$test_cygdrive_prefix" = x; then
32268 # As a simple fix, exclude /usr/bin since it's not a real path.
32269 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
32270 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32271 # a path prefixed by /cygdrive for fixpath to work.
32272 new_path="$CYGWIN_ROOT_PATH$input_path"
32273 fi
32274 fi
32275
32276 # remove trailing .exe if any
32277 new_path="${new_path/%.exe/}"
32278
32279 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32280
32708 fi
32709
32710 # Call helper function which possibly converts this using DOS-style short mode.
32711 # If so, the updated path is stored in $new_path.
32712 new_path="$input_to_shortpath"
32713
32714 input_path="$input_to_shortpath"
32715 # Check if we need to convert this using DOS-style short mode. If the path
32716 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32717 # take no chances and rewrite it.
32718 # Note: m4 eats our [], so we need to use [ and ] instead.
32719 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32720 if test "x$has_forbidden_chars" != x; then
32721 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32722 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32723 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32724 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32725 # Going to short mode and back again did indeed matter. Since short mode is
32726 # case insensitive, let's make it lowercase to improve readability.
32727 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32728 # Now convert it back to Unix-stile (cygpath)
32729 input_path=`$CYGPATH -u "$shortmode_path"`
32730 new_path="$input_path"
32731 fi
32732 fi
32733
32734 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32735 if test "x$test_cygdrive_prefix" = x; then
32736 # As a simple fix, exclude /usr/bin since it's not a real path.
32737 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
32738 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32739 # a path prefixed by /cygdrive for fixpath to work.
32740 new_path="$CYGWIN_ROOT_PATH$input_path"
32741 fi
32742 fi
32743
32744 # remove trailing .exe if any
32745 new_path="${new_path/%.exe/}"
32746
32747 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32748
33049 fi
33050
33051 # Call helper function which possibly converts this using DOS-style short mode.
33052 # If so, the updated path is stored in $new_path.
33053 new_path="$input_to_shortpath"
33054
33055 input_path="$input_to_shortpath"
33056 # Check if we need to convert this using DOS-style short mode. If the path
33057 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33058 # take no chances and rewrite it.
33059 # Note: m4 eats our [], so we need to use [ and ] instead.
33060 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33061 if test "x$has_forbidden_chars" != x; then
33062 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33063 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33064 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33065 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33066 # Going to short mode and back again did indeed matter. Since short mode is
33067 # case insensitive, let's make it lowercase to improve readability.
33068 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33069 # Now convert it back to Unix-stile (cygpath)
33070 input_path=`$CYGPATH -u "$shortmode_path"`
33071 new_path="$input_path"
33072 fi
33073 fi
33074
33075 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33076 if test "x$test_cygdrive_prefix" = x; then
33077 # As a simple fix, exclude /usr/bin since it's not a real path.
33078 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33079 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33080 # a path prefixed by /cygdrive for fixpath to work.
33081 new_path="$CYGWIN_ROOT_PATH$input_path"
33082 fi
33083 fi
33084
33085 # remove trailing .exe if any
33086 new_path="${new_path/%.exe/}"
33087
33088 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33089
33386 fi
33387
33388 # Call helper function which possibly converts this using DOS-style short mode.
33389 # If so, the updated path is stored in $new_path.
33390 new_path="$input_to_shortpath"
33391
33392 input_path="$input_to_shortpath"
33393 # Check if we need to convert this using DOS-style short mode. If the path
33394 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33395 # take no chances and rewrite it.
33396 # Note: m4 eats our [], so we need to use [ and ] instead.
33397 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33398 if test "x$has_forbidden_chars" != x; then
33399 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33400 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33401 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33402 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33403 # Going to short mode and back again did indeed matter. Since short mode is
33404 # case insensitive, let's make it lowercase to improve readability.
33405 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33406 # Now convert it back to Unix-stile (cygpath)
33407 input_path=`$CYGPATH -u "$shortmode_path"`
33408 new_path="$input_path"
33409 fi
33410 fi
33411
33412 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33413 if test "x$test_cygdrive_prefix" = x; then
33414 # As a simple fix, exclude /usr/bin since it's not a real path.
33415 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33416 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33417 # a path prefixed by /cygdrive for fixpath to work.
33418 new_path="$CYGWIN_ROOT_PATH$input_path"
33419 fi
33420 fi
33421
33422 # remove trailing .exe if any
33423 new_path="${new_path/%.exe/}"
33424
33425 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33426
33705 fi
33706
33707 # Call helper function which possibly converts this using DOS-style short mode.
33708 # If so, the updated path is stored in $new_path.
33709 new_path="$input_to_shortpath"
33710
33711 input_path="$input_to_shortpath"
33712 # Check if we need to convert this using DOS-style short mode. If the path
33713 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33714 # take no chances and rewrite it.
33715 # Note: m4 eats our [], so we need to use [ and ] instead.
33716 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33717 if test "x$has_forbidden_chars" != x; then
33718 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33719 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33720 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33721 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33722 # Going to short mode and back again did indeed matter. Since short mode is
33723 # case insensitive, let's make it lowercase to improve readability.
33724 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33725 # Now convert it back to Unix-stile (cygpath)
33726 input_path=`$CYGPATH -u "$shortmode_path"`
33727 new_path="$input_path"
33728 fi
33729 fi
33730
33731 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33732 if test "x$test_cygdrive_prefix" = x; then
33733 # As a simple fix, exclude /usr/bin since it's not a real path.
33734 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33735 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33736 # a path prefixed by /cygdrive for fixpath to work.
33737 new_path="$CYGWIN_ROOT_PATH$input_path"
33738 fi
33739 fi
33740
33741 # remove trailing .exe if any
33742 new_path="${new_path/%.exe/}"
33743
33744 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33745
34220 fi
34221
34222 # Call helper function which possibly converts this using DOS-style short mode.
34223 # If so, the updated path is stored in $new_path.
34224 new_path="$input_to_shortpath"
34225
34226 input_path="$input_to_shortpath"
34227 # Check if we need to convert this using DOS-style short mode. If the path
34228 # contains just simple characters, use it. Otherwise (spaces, weird characters),
34229 # take no chances and rewrite it.
34230 # Note: m4 eats our [], so we need to use [ and ] instead.
34231 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
34232 if test "x$has_forbidden_chars" != x; then
34233 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
34234 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
34235 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
34236 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
34237 # Going to short mode and back again did indeed matter. Since short mode is
34238 # case insensitive, let's make it lowercase to improve readability.
34239 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
34240 # Now convert it back to Unix-stile (cygpath)
34241 input_path=`$CYGPATH -u "$shortmode_path"`
34242 new_path="$input_path"
34243 fi
34244 fi
34245
34246 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
34247 if test "x$test_cygdrive_prefix" = x; then
34248 # As a simple fix, exclude /usr/bin since it's not a real path.
34249 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
34250 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
34251 # a path prefixed by /cygdrive for fixpath to work.
34252 new_path="$CYGWIN_ROOT_PATH$input_path"
34253 fi
34254 fi
34255
34256 # remove trailing .exe if any
34257 new_path="${new_path/%.exe/}"
34258
34259 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34260
34688 fi
34689
34690 # Call helper function which possibly converts this using DOS-style short mode.
34691 # If so, the updated path is stored in $new_path.
34692 new_path="$input_to_shortpath"
34693
34694 input_path="$input_to_shortpath"
34695 # Check if we need to convert this using DOS-style short mode. If the path
34696 # contains just simple characters, use it. Otherwise (spaces, weird characters),
34697 # take no chances and rewrite it.
34698 # Note: m4 eats our [], so we need to use [ and ] instead.
34699 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
34700 if test "x$has_forbidden_chars" != x; then
34701 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
34702 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
34703 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
34704 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
34705 # Going to short mode and back again did indeed matter. Since short mode is
34706 # case insensitive, let's make it lowercase to improve readability.
34707 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
34708 # Now convert it back to Unix-stile (cygpath)
34709 input_path=`$CYGPATH -u "$shortmode_path"`
34710 new_path="$input_path"
34711 fi
34712 fi
34713
34714 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
34715 if test "x$test_cygdrive_prefix" = x; then
34716 # As a simple fix, exclude /usr/bin since it's not a real path.
34717 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
34718 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
34719 # a path prefixed by /cygdrive for fixpath to work.
34720 new_path="$CYGWIN_ROOT_PATH$input_path"
34721 fi
34722 fi
34723
34724 # remove trailing .exe if any
34725 new_path="${new_path/%.exe/}"
34726
34727 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34728
35156 fi
35157
35158 # Call helper function which possibly converts this using DOS-style short mode.
35159 # If so, the updated path is stored in $new_path.
35160 new_path="$input_to_shortpath"
35161
35162 input_path="$input_to_shortpath"
35163 # Check if we need to convert this using DOS-style short mode. If the path
35164 # contains just simple characters, use it. Otherwise (spaces, weird characters),
35165 # take no chances and rewrite it.
35166 # Note: m4 eats our [], so we need to use [ and ] instead.
35167 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
35168 if test "x$has_forbidden_chars" != x; then
35169 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
35170 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
35171 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
35172 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
35173 # Going to short mode and back again did indeed matter. Since short mode is
35174 # case insensitive, let's make it lowercase to improve readability.
35175 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
35176 # Now convert it back to Unix-stile (cygpath)
35177 input_path=`$CYGPATH -u "$shortmode_path"`
35178 new_path="$input_path"
35179 fi
35180 fi
35181
35182 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
35183 if test "x$test_cygdrive_prefix" = x; then
35184 # As a simple fix, exclude /usr/bin since it's not a real path.
35185 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
35186 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
35187 # a path prefixed by /cygdrive for fixpath to work.
35188 new_path="$CYGWIN_ROOT_PATH$input_path"
35189 fi
35190 fi
35191
35192 # remove trailing .exe if any
35193 new_path="${new_path/%.exe/}"
35194
35195 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35196
35625 fi
35626
35627 # Call helper function which possibly converts this using DOS-style short mode.
35628 # If so, the updated path is stored in $new_path.
35629 new_path="$input_to_shortpath"
35630
35631 input_path="$input_to_shortpath"
35632 # Check if we need to convert this using DOS-style short mode. If the path
35633 # contains just simple characters, use it. Otherwise (spaces, weird characters),
35634 # take no chances and rewrite it.
35635 # Note: m4 eats our [], so we need to use [ and ] instead.
35636 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
35637 if test "x$has_forbidden_chars" != x; then
35638 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
35639 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
35640 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
35641 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
35642 # Going to short mode and back again did indeed matter. Since short mode is
35643 # case insensitive, let's make it lowercase to improve readability.
35644 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
35645 # Now convert it back to Unix-stile (cygpath)
35646 input_path=`$CYGPATH -u "$shortmode_path"`
35647 new_path="$input_path"
35648 fi
35649 fi
35650
35651 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
35652 if test "x$test_cygdrive_prefix" = x; then
35653 # As a simple fix, exclude /usr/bin since it's not a real path.
35654 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
35655 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
35656 # a path prefixed by /cygdrive for fixpath to work.
35657 new_path="$CYGWIN_ROOT_PATH$input_path"
35658 fi
35659 fi
35660
35661 # remove trailing .exe if any
35662 new_path="${new_path/%.exe/}"
35663
35664 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35665
36205 fi
36206
36207 # Call helper function which possibly converts this using DOS-style short mode.
36208 # If so, the updated path is stored in $new_path.
36209 new_path="$input_to_shortpath"
36210
36211 input_path="$input_to_shortpath"
36212 # Check if we need to convert this using DOS-style short mode. If the path
36213 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36214 # take no chances and rewrite it.
36215 # Note: m4 eats our [], so we need to use [ and ] instead.
36216 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36217 if test "x$has_forbidden_chars" != x; then
36218 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36219 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36220 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36221 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36222 # Going to short mode and back again did indeed matter. Since short mode is
36223 # case insensitive, let's make it lowercase to improve readability.
36224 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36225 # Now convert it back to Unix-stile (cygpath)
36226 input_path=`$CYGPATH -u "$shortmode_path"`
36227 new_path="$input_path"
36228 fi
36229 fi
36230
36231 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36232 if test "x$test_cygdrive_prefix" = x; then
36233 # As a simple fix, exclude /usr/bin since it's not a real path.
36234 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36235 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36236 # a path prefixed by /cygdrive for fixpath to work.
36237 new_path="$CYGWIN_ROOT_PATH$input_path"
36238 fi
36239 fi
36240
36241 # remove trailing .exe if any
36242 new_path="${new_path/%.exe/}"
36243
36244 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36245
36826 fi
36827
36828 # Call helper function which possibly converts this using DOS-style short mode.
36829 # If so, the updated path is stored in $new_path.
36830 new_path="$input_to_shortpath"
36831
36832 input_path="$input_to_shortpath"
36833 # Check if we need to convert this using DOS-style short mode. If the path
36834 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36835 # take no chances and rewrite it.
36836 # Note: m4 eats our [], so we need to use [ and ] instead.
36837 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36838 if test "x$has_forbidden_chars" != x; then
36839 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36840 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36841 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36842 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36843 # Going to short mode and back again did indeed matter. Since short mode is
36844 # case insensitive, let's make it lowercase to improve readability.
36845 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36846 # Now convert it back to Unix-stile (cygpath)
36847 input_path=`$CYGPATH -u "$shortmode_path"`
36848 new_path="$input_path"
36849 fi
36850 fi
36851
36852 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36853 if test "x$test_cygdrive_prefix" = x; then
36854 # As a simple fix, exclude /usr/bin since it's not a real path.
36855 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36856 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36857 # a path prefixed by /cygdrive for fixpath to work.
36858 new_path="$CYGWIN_ROOT_PATH$input_path"
36859 fi
36860 fi
36861
36862 # remove trailing .exe if any
36863 new_path="${new_path/%.exe/}"
36864
36865 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36866
37413 fi
37414
37415 # Call helper function which possibly converts this using DOS-style short mode.
37416 # If so, the updated path is stored in $new_path.
37417 new_path="$input_to_shortpath"
37418
37419 input_path="$input_to_shortpath"
37420 # Check if we need to convert this using DOS-style short mode. If the path
37421 # contains just simple characters, use it. Otherwise (spaces, weird characters),
37422 # take no chances and rewrite it.
37423 # Note: m4 eats our [], so we need to use [ and ] instead.
37424 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
37425 if test "x$has_forbidden_chars" != x; then
37426 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
37427 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
37428 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
37429 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
37430 # Going to short mode and back again did indeed matter. Since short mode is
37431 # case insensitive, let's make it lowercase to improve readability.
37432 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
37433 # Now convert it back to Unix-stile (cygpath)
37434 input_path=`$CYGPATH -u "$shortmode_path"`
37435 new_path="$input_path"
37436 fi
37437 fi
37438
37439 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
37440 if test "x$test_cygdrive_prefix" = x; then
37441 # As a simple fix, exclude /usr/bin since it's not a real path.
37442 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
37443 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
37444 # a path prefixed by /cygdrive for fixpath to work.
37445 new_path="$CYGWIN_ROOT_PATH$input_path"
37446 fi
37447 fi
37448
37449 # remove trailing .exe if any
37450 new_path="${new_path/%.exe/}"
37451
37452 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37453
37997 fi
37998
37999 # Call helper function which possibly converts this using DOS-style short mode.
38000 # If so, the updated path is stored in $new_path.
38001 new_path="$input_to_shortpath"
38002
38003 input_path="$input_to_shortpath"
38004 # Check if we need to convert this using DOS-style short mode. If the path
38005 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38006 # take no chances and rewrite it.
38007 # Note: m4 eats our [], so we need to use [ and ] instead.
38008 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38009 if test "x$has_forbidden_chars" != x; then
38010 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38011 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38012 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38013 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38014 # Going to short mode and back again did indeed matter. Since short mode is
38015 # case insensitive, let's make it lowercase to improve readability.
38016 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38017 # Now convert it back to Unix-stile (cygpath)
38018 input_path=`$CYGPATH -u "$shortmode_path"`
38019 new_path="$input_path"
38020 fi
38021 fi
38022
38023 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38024 if test "x$test_cygdrive_prefix" = x; then
38025 # As a simple fix, exclude /usr/bin since it's not a real path.
38026 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38027 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38028 # a path prefixed by /cygdrive for fixpath to work.
38029 new_path="$CYGWIN_ROOT_PATH$input_path"
38030 fi
38031 fi
38032
38033 # remove trailing .exe if any
38034 new_path="${new_path/%.exe/}"
38035
38036 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38037
38490 fi
38491
38492 # Call helper function which possibly converts this using DOS-style short mode.
38493 # If so, the updated path is stored in $new_path.
38494 new_path="$input_to_shortpath"
38495
38496 input_path="$input_to_shortpath"
38497 # Check if we need to convert this using DOS-style short mode. If the path
38498 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38499 # take no chances and rewrite it.
38500 # Note: m4 eats our [], so we need to use [ and ] instead.
38501 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38502 if test "x$has_forbidden_chars" != x; then
38503 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38504 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38505 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38506 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38507 # Going to short mode and back again did indeed matter. Since short mode is
38508 # case insensitive, let's make it lowercase to improve readability.
38509 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38510 # Now convert it back to Unix-stile (cygpath)
38511 input_path=`$CYGPATH -u "$shortmode_path"`
38512 new_path="$input_path"
38513 fi
38514 fi
38515
38516 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38517 if test "x$test_cygdrive_prefix" = x; then
38518 # As a simple fix, exclude /usr/bin since it's not a real path.
38519 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38520 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38521 # a path prefixed by /cygdrive for fixpath to work.
38522 new_path="$CYGWIN_ROOT_PATH$input_path"
38523 fi
38524 fi
38525
38526 # remove trailing .exe if any
38527 new_path="${new_path/%.exe/}"
38528
38529 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38530
38958 fi
38959
38960 # Call helper function which possibly converts this using DOS-style short mode.
38961 # If so, the updated path is stored in $new_path.
38962 new_path="$input_to_shortpath"
38963
38964 input_path="$input_to_shortpath"
38965 # Check if we need to convert this using DOS-style short mode. If the path
38966 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38967 # take no chances and rewrite it.
38968 # Note: m4 eats our [], so we need to use [ and ] instead.
38969 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38970 if test "x$has_forbidden_chars" != x; then
38971 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38972 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38973 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38974 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38975 # Going to short mode and back again did indeed matter. Since short mode is
38976 # case insensitive, let's make it lowercase to improve readability.
38977 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38978 # Now convert it back to Unix-stile (cygpath)
38979 input_path=`$CYGPATH -u "$shortmode_path"`
38980 new_path="$input_path"
38981 fi
38982 fi
38983
38984 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38985 if test "x$test_cygdrive_prefix" = x; then
38986 # As a simple fix, exclude /usr/bin since it's not a real path.
38987 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38988 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38989 # a path prefixed by /cygdrive for fixpath to work.
38990 new_path="$CYGWIN_ROOT_PATH$input_path"
38991 fi
38992 fi
38993
38994 # remove trailing .exe if any
38995 new_path="${new_path/%.exe/}"
38996
38997 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38998
39426 fi
39427
39428 # Call helper function which possibly converts this using DOS-style short mode.
39429 # If so, the updated path is stored in $new_path.
39430 new_path="$input_to_shortpath"
39431
39432 input_path="$input_to_shortpath"
39433 # Check if we need to convert this using DOS-style short mode. If the path
39434 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39435 # take no chances and rewrite it.
39436 # Note: m4 eats our [], so we need to use [ and ] instead.
39437 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39438 if test "x$has_forbidden_chars" != x; then
39439 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39440 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39441 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39442 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39443 # Going to short mode and back again did indeed matter. Since short mode is
39444 # case insensitive, let's make it lowercase to improve readability.
39445 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39446 # Now convert it back to Unix-stile (cygpath)
39447 input_path=`$CYGPATH -u "$shortmode_path"`
39448 new_path="$input_path"
39449 fi
39450 fi
39451
39452 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39453 if test "x$test_cygdrive_prefix" = x; then
39454 # As a simple fix, exclude /usr/bin since it's not a real path.
39455 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
39456 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39457 # a path prefixed by /cygdrive for fixpath to work.
39458 new_path="$CYGWIN_ROOT_PATH$input_path"
39459 fi
39460 fi
39461
39462 # remove trailing .exe if any
39463 new_path="${new_path/%.exe/}"
39464
39465 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39466
39806 as_fn_error $? "Cannot locate the the path of JT_HOME" "$LINENO" 5
39807 fi
39808
39809 # Call helper function which possibly converts this using DOS-style short mode.
39810 # If so, the updated path is stored in $new_path.
39811
39812 input_path="$new_path"
39813 # Check if we need to convert this using DOS-style short mode. If the path
39814 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39815 # take no chances and rewrite it.
39816 # Note: m4 eats our [], so we need to use [ and ] instead.
39817 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39818 if test "x$has_forbidden_chars" != x; then
39819 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39820 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39821 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39822 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39823 # Going to short mode and back again did indeed matter. Since short mode is
39824 # case insensitive, let's make it lowercase to improve readability.
39825 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39826 # Now convert it back to Unix-stile (cygpath)
39827 input_path=`$CYGPATH -u "$shortmode_path"`
39828 new_path="$input_path"
39829 fi
39830 fi
39831
39832 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39833 if test "x$test_cygdrive_prefix" = x; then
39834 # As a simple fix, exclude /usr/bin since it's not a real path.
39835 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
39836 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39837 # a path prefixed by /cygdrive for fixpath to work.
39838 new_path="$CYGWIN_ROOT_PATH$input_path"
39839 fi
39840 fi
39841
39842
39843 if test "x$path" != "x$new_path"; then
39844 JT_HOME="$new_path"
39845 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
39846 $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
43343 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
43344 fi
43345
43346 # Call helper function which possibly converts this using DOS-style short mode.
43347 # If so, the updated path is stored in $new_path.
43348
43349 input_path="$new_path"
43350 # Check if we need to convert this using DOS-style short mode. If the path
43351 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43352 # take no chances and rewrite it.
43353 # Note: m4 eats our [], so we need to use [ and ] instead.
43354 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43355 if test "x$has_forbidden_chars" != x; then
43356 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43357 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43358 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43359 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43360 # Going to short mode and back again did indeed matter. Since short mode is
43361 # case insensitive, let's make it lowercase to improve readability.
43362 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43363 # Now convert it back to Unix-stile (cygpath)
43364 input_path=`$CYGPATH -u "$shortmode_path"`
43365 new_path="$input_path"
43366 fi
43367 fi
43368
43369 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43370 if test "x$test_cygdrive_prefix" = x; then
43371 # As a simple fix, exclude /usr/bin since it's not a real path.
43372 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43373 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43374 # a path prefixed by /cygdrive for fixpath to work.
43375 new_path="$CYGWIN_ROOT_PATH$input_path"
43376 fi
43377 fi
43378
43379
43380 if test "x$path" != "x$new_path"; then
43381 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
43382 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
43383 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
43465 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
43466 fi
43467
43468 # Call helper function which possibly converts this using DOS-style short mode.
43469 # If so, the updated path is stored in $new_path.
43470
43471 input_path="$new_path"
43472 # Check if we need to convert this using DOS-style short mode. If the path
43473 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43474 # take no chances and rewrite it.
43475 # Note: m4 eats our [], so we need to use [ and ] instead.
43476 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43477 if test "x$has_forbidden_chars" != x; then
43478 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43479 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43480 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43481 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43482 # Going to short mode and back again did indeed matter. Since short mode is
43483 # case insensitive, let's make it lowercase to improve readability.
43484 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43485 # Now convert it back to Unix-stile (cygpath)
43486 input_path=`$CYGPATH -u "$shortmode_path"`
43487 new_path="$input_path"
43488 fi
43489 fi
43490
43491 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43492 if test "x$test_cygdrive_prefix" = x; then
43493 # As a simple fix, exclude /usr/bin since it's not a real path.
43494 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43495 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43496 # a path prefixed by /cygdrive for fixpath to work.
43497 new_path="$CYGWIN_ROOT_PATH$input_path"
43498 fi
43499 fi
43500
43501
43502 if test "x$path" != "x$new_path"; then
43503 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
43504 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
43505 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
43670 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
43671 fi
43672
43673 # Call helper function which possibly converts this using DOS-style short mode.
43674 # If so, the updated path is stored in $new_path.
43675
43676 input_path="$new_path"
43677 # Check if we need to convert this using DOS-style short mode. If the path
43678 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43679 # take no chances and rewrite it.
43680 # Note: m4 eats our [], so we need to use [ and ] instead.
43681 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43682 if test "x$has_forbidden_chars" != x; then
43683 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43684 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43685 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43686 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43687 # Going to short mode and back again did indeed matter. Since short mode is
43688 # case insensitive, let's make it lowercase to improve readability.
43689 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43690 # Now convert it back to Unix-stile (cygpath)
43691 input_path=`$CYGPATH -u "$shortmode_path"`
43692 new_path="$input_path"
43693 fi
43694 fi
43695
43696 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43697 if test "x$test_cygdrive_prefix" = x; then
43698 # As a simple fix, exclude /usr/bin since it's not a real path.
43699 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43700 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43701 # a path prefixed by /cygdrive for fixpath to work.
43702 new_path="$CYGWIN_ROOT_PATH$input_path"
43703 fi
43704 fi
43705
43706
43707 if test "x$path" != "x$new_path"; then
43708 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
43709 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
43710 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
43792 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
43793 fi
43794
43795 # Call helper function which possibly converts this using DOS-style short mode.
43796 # If so, the updated path is stored in $new_path.
43797
43798 input_path="$new_path"
43799 # Check if we need to convert this using DOS-style short mode. If the path
43800 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43801 # take no chances and rewrite it.
43802 # Note: m4 eats our [], so we need to use [ and ] instead.
43803 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43804 if test "x$has_forbidden_chars" != x; then
43805 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43806 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43807 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43808 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43809 # Going to short mode and back again did indeed matter. Since short mode is
43810 # case insensitive, let's make it lowercase to improve readability.
43811 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43812 # Now convert it back to Unix-stile (cygpath)
43813 input_path=`$CYGPATH -u "$shortmode_path"`
43814 new_path="$input_path"
43815 fi
43816 fi
43817
43818 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43819 if test "x$test_cygdrive_prefix" = x; then
43820 # As a simple fix, exclude /usr/bin since it's not a real path.
43821 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43822 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43823 # a path prefixed by /cygdrive for fixpath to work.
43824 new_path="$CYGWIN_ROOT_PATH$input_path"
43825 fi
43826 fi
43827
43828
43829 if test "x$path" != "x$new_path"; then
43830 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
43831 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
43832 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44258 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
44259 fi
44260
44261 # Call helper function which possibly converts this using DOS-style short mode.
44262 # If so, the updated path is stored in $new_path.
44263
44264 input_path="$new_path"
44265 # Check if we need to convert this using DOS-style short mode. If the path
44266 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44267 # take no chances and rewrite it.
44268 # Note: m4 eats our [], so we need to use [ and ] instead.
44269 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44270 if test "x$has_forbidden_chars" != x; then
44271 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44272 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44273 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44274 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44275 # Going to short mode and back again did indeed matter. Since short mode is
44276 # case insensitive, let's make it lowercase to improve readability.
44277 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44278 # Now convert it back to Unix-stile (cygpath)
44279 input_path=`$CYGPATH -u "$shortmode_path"`
44280 new_path="$input_path"
44281 fi
44282 fi
44283
44284 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44285 if test "x$test_cygdrive_prefix" = x; then
44286 # As a simple fix, exclude /usr/bin since it's not a real path.
44287 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44288 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44289 # a path prefixed by /cygdrive for fixpath to work.
44290 new_path="$CYGWIN_ROOT_PATH$input_path"
44291 fi
44292 fi
44293
44294
44295 if test "x$path" != "x$new_path"; then
44296 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44297 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44298 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44380 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
44381 fi
44382
44383 # Call helper function which possibly converts this using DOS-style short mode.
44384 # If so, the updated path is stored in $new_path.
44385
44386 input_path="$new_path"
44387 # Check if we need to convert this using DOS-style short mode. If the path
44388 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44389 # take no chances and rewrite it.
44390 # Note: m4 eats our [], so we need to use [ and ] instead.
44391 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44392 if test "x$has_forbidden_chars" != x; then
44393 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44394 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44395 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44396 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44397 # Going to short mode and back again did indeed matter. Since short mode is
44398 # case insensitive, let's make it lowercase to improve readability.
44399 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44400 # Now convert it back to Unix-stile (cygpath)
44401 input_path=`$CYGPATH -u "$shortmode_path"`
44402 new_path="$input_path"
44403 fi
44404 fi
44405
44406 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44407 if test "x$test_cygdrive_prefix" = x; then
44408 # As a simple fix, exclude /usr/bin since it's not a real path.
44409 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44410 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44411 # a path prefixed by /cygdrive for fixpath to work.
44412 new_path="$CYGWIN_ROOT_PATH$input_path"
44413 fi
44414 fi
44415
44416
44417 if test "x$path" != "x$new_path"; then
44418 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
44419 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
44420 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44560 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
44561 fi
44562
44563 # Call helper function which possibly converts this using DOS-style short mode.
44564 # If so, the updated path is stored in $new_path.
44565
44566 input_path="$new_path"
44567 # Check if we need to convert this using DOS-style short mode. If the path
44568 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44569 # take no chances and rewrite it.
44570 # Note: m4 eats our [], so we need to use [ and ] instead.
44571 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44572 if test "x$has_forbidden_chars" != x; then
44573 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44574 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44575 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44576 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44577 # Going to short mode and back again did indeed matter. Since short mode is
44578 # case insensitive, let's make it lowercase to improve readability.
44579 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44580 # Now convert it back to Unix-stile (cygpath)
44581 input_path=`$CYGPATH -u "$shortmode_path"`
44582 new_path="$input_path"
44583 fi
44584 fi
44585
44586 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44587 if test "x$test_cygdrive_prefix" = x; then
44588 # As a simple fix, exclude /usr/bin since it's not a real path.
44589 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44590 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44591 # a path prefixed by /cygdrive for fixpath to work.
44592 new_path="$CYGWIN_ROOT_PATH$input_path"
44593 fi
44594 fi
44595
44596
44597 if test "x$path" != "x$new_path"; then
44598 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44599 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44600 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44682 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
44683 fi
44684
44685 # Call helper function which possibly converts this using DOS-style short mode.
44686 # If so, the updated path is stored in $new_path.
44687
44688 input_path="$new_path"
44689 # Check if we need to convert this using DOS-style short mode. If the path
44690 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44691 # take no chances and rewrite it.
44692 # Note: m4 eats our [], so we need to use [ and ] instead.
44693 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44694 if test "x$has_forbidden_chars" != x; then
44695 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44696 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44697 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44698 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44699 # Going to short mode and back again did indeed matter. Since short mode is
44700 # case insensitive, let's make it lowercase to improve readability.
44701 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44702 # Now convert it back to Unix-stile (cygpath)
44703 input_path=`$CYGPATH -u "$shortmode_path"`
44704 new_path="$input_path"
44705 fi
44706 fi
44707
44708 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44709 if test "x$test_cygdrive_prefix" = x; then
44710 # As a simple fix, exclude /usr/bin since it's not a real path.
44711 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44712 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44713 # a path prefixed by /cygdrive for fixpath to work.
44714 new_path="$CYGWIN_ROOT_PATH$input_path"
44715 fi
44716 fi
44717
44718
44719 if test "x$path" != "x$new_path"; then
44720 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
44721 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
44722 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44853 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
44854 fi
44855
44856 # Call helper function which possibly converts this using DOS-style short mode.
44857 # If so, the updated path is stored in $new_path.
44858
44859 input_path="$new_path"
44860 # Check if we need to convert this using DOS-style short mode. If the path
44861 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44862 # take no chances and rewrite it.
44863 # Note: m4 eats our [], so we need to use [ and ] instead.
44864 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44865 if test "x$has_forbidden_chars" != x; then
44866 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44867 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44868 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44869 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44870 # Going to short mode and back again did indeed matter. Since short mode is
44871 # case insensitive, let's make it lowercase to improve readability.
44872 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44873 # Now convert it back to Unix-stile (cygpath)
44874 input_path=`$CYGPATH -u "$shortmode_path"`
44875 new_path="$input_path"
44876 fi
44877 fi
44878
44879 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44880 if test "x$test_cygdrive_prefix" = x; then
44881 # As a simple fix, exclude /usr/bin since it's not a real path.
44882 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44883 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44884 # a path prefixed by /cygdrive for fixpath to work.
44885 new_path="$CYGWIN_ROOT_PATH$input_path"
44886 fi
44887 fi
44888
44889
44890 if test "x$path" != "x$new_path"; then
44891 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44892 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44893 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44975 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
44976 fi
44977
44978 # Call helper function which possibly converts this using DOS-style short mode.
44979 # If so, the updated path is stored in $new_path.
44980
44981 input_path="$new_path"
44982 # Check if we need to convert this using DOS-style short mode. If the path
44983 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44984 # take no chances and rewrite it.
44985 # Note: m4 eats our [], so we need to use [ and ] instead.
44986 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44987 if test "x$has_forbidden_chars" != x; then
44988 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44989 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44990 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44991 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44992 # Going to short mode and back again did indeed matter. Since short mode is
44993 # case insensitive, let's make it lowercase to improve readability.
44994 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44995 # Now convert it back to Unix-stile (cygpath)
44996 input_path=`$CYGPATH -u "$shortmode_path"`
44997 new_path="$input_path"
44998 fi
44999 fi
45000
45001 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45002 if test "x$test_cygdrive_prefix" = x; then
45003 # As a simple fix, exclude /usr/bin since it's not a real path.
45004 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45005 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45006 # a path prefixed by /cygdrive for fixpath to work.
45007 new_path="$CYGWIN_ROOT_PATH$input_path"
45008 fi
45009 fi
45010
45011
45012 if test "x$path" != "x$new_path"; then
45013 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45014 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45015 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45146 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
45147 fi
45148
45149 # Call helper function which possibly converts this using DOS-style short mode.
45150 # If so, the updated path is stored in $new_path.
45151
45152 input_path="$new_path"
45153 # Check if we need to convert this using DOS-style short mode. If the path
45154 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45155 # take no chances and rewrite it.
45156 # Note: m4 eats our [], so we need to use [ and ] instead.
45157 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45158 if test "x$has_forbidden_chars" != x; then
45159 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45160 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45161 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45162 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45163 # Going to short mode and back again did indeed matter. Since short mode is
45164 # case insensitive, let's make it lowercase to improve readability.
45165 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45166 # Now convert it back to Unix-stile (cygpath)
45167 input_path=`$CYGPATH -u "$shortmode_path"`
45168 new_path="$input_path"
45169 fi
45170 fi
45171
45172 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45173 if test "x$test_cygdrive_prefix" = x; then
45174 # As a simple fix, exclude /usr/bin since it's not a real path.
45175 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45176 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45177 # a path prefixed by /cygdrive for fixpath to work.
45178 new_path="$CYGWIN_ROOT_PATH$input_path"
45179 fi
45180 fi
45181
45182
45183 if test "x$path" != "x$new_path"; then
45184 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45185 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45186 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45268 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45269 fi
45270
45271 # Call helper function which possibly converts this using DOS-style short mode.
45272 # If so, the updated path is stored in $new_path.
45273
45274 input_path="$new_path"
45275 # Check if we need to convert this using DOS-style short mode. If the path
45276 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45277 # take no chances and rewrite it.
45278 # Note: m4 eats our [], so we need to use [ and ] instead.
45279 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45280 if test "x$has_forbidden_chars" != x; then
45281 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45282 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45283 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45284 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45285 # Going to short mode and back again did indeed matter. Since short mode is
45286 # case insensitive, let's make it lowercase to improve readability.
45287 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45288 # Now convert it back to Unix-stile (cygpath)
45289 input_path=`$CYGPATH -u "$shortmode_path"`
45290 new_path="$input_path"
45291 fi
45292 fi
45293
45294 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45295 if test "x$test_cygdrive_prefix" = x; then
45296 # As a simple fix, exclude /usr/bin since it's not a real path.
45297 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45298 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45299 # a path prefixed by /cygdrive for fixpath to work.
45300 new_path="$CYGWIN_ROOT_PATH$input_path"
45301 fi
45302 fi
45303
45304
45305 if test "x$path" != "x$new_path"; then
45306 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45307 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45308 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45440 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
45441 fi
45442
45443 # Call helper function which possibly converts this using DOS-style short mode.
45444 # If so, the updated path is stored in $new_path.
45445
45446 input_path="$new_path"
45447 # Check if we need to convert this using DOS-style short mode. If the path
45448 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45449 # take no chances and rewrite it.
45450 # Note: m4 eats our [], so we need to use [ and ] instead.
45451 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45452 if test "x$has_forbidden_chars" != x; then
45453 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45454 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45455 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45456 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45457 # Going to short mode and back again did indeed matter. Since short mode is
45458 # case insensitive, let's make it lowercase to improve readability.
45459 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45460 # Now convert it back to Unix-stile (cygpath)
45461 input_path=`$CYGPATH -u "$shortmode_path"`
45462 new_path="$input_path"
45463 fi
45464 fi
45465
45466 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45467 if test "x$test_cygdrive_prefix" = x; then
45468 # As a simple fix, exclude /usr/bin since it's not a real path.
45469 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45470 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45471 # a path prefixed by /cygdrive for fixpath to work.
45472 new_path="$CYGWIN_ROOT_PATH$input_path"
45473 fi
45474 fi
45475
45476
45477 if test "x$path" != "x$new_path"; then
45478 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45479 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45480 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45562 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45563 fi
45564
45565 # Call helper function which possibly converts this using DOS-style short mode.
45566 # If so, the updated path is stored in $new_path.
45567
45568 input_path="$new_path"
45569 # Check if we need to convert this using DOS-style short mode. If the path
45570 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45571 # take no chances and rewrite it.
45572 # Note: m4 eats our [], so we need to use [ and ] instead.
45573 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45574 if test "x$has_forbidden_chars" != x; then
45575 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45576 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45577 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45578 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45579 # Going to short mode and back again did indeed matter. Since short mode is
45580 # case insensitive, let's make it lowercase to improve readability.
45581 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45582 # Now convert it back to Unix-stile (cygpath)
45583 input_path=`$CYGPATH -u "$shortmode_path"`
45584 new_path="$input_path"
45585 fi
45586 fi
45587
45588 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45589 if test "x$test_cygdrive_prefix" = x; then
45590 # As a simple fix, exclude /usr/bin since it's not a real path.
45591 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45592 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45593 # a path prefixed by /cygdrive for fixpath to work.
45594 new_path="$CYGWIN_ROOT_PATH$input_path"
45595 fi
45596 fi
45597
45598
45599 if test "x$path" != "x$new_path"; then
45600 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45601 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45602 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45735 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
45736 fi
45737
45738 # Call helper function which possibly converts this using DOS-style short mode.
45739 # If so, the updated path is stored in $new_path.
45740
45741 input_path="$new_path"
45742 # Check if we need to convert this using DOS-style short mode. If the path
45743 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45744 # take no chances and rewrite it.
45745 # Note: m4 eats our [], so we need to use [ and ] instead.
45746 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45747 if test "x$has_forbidden_chars" != x; then
45748 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45749 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45750 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45751 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45752 # Going to short mode and back again did indeed matter. Since short mode is
45753 # case insensitive, let's make it lowercase to improve readability.
45754 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45755 # Now convert it back to Unix-stile (cygpath)
45756 input_path=`$CYGPATH -u "$shortmode_path"`
45757 new_path="$input_path"
45758 fi
45759 fi
45760
45761 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45762 if test "x$test_cygdrive_prefix" = x; then
45763 # As a simple fix, exclude /usr/bin since it's not a real path.
45764 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45765 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45766 # a path prefixed by /cygdrive for fixpath to work.
45767 new_path="$CYGWIN_ROOT_PATH$input_path"
45768 fi
45769 fi
45770
45771
45772 if test "x$path" != "x$new_path"; then
45773 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45774 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45775 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45857 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45858 fi
45859
45860 # Call helper function which possibly converts this using DOS-style short mode.
45861 # If so, the updated path is stored in $new_path.
45862
45863 input_path="$new_path"
45864 # Check if we need to convert this using DOS-style short mode. If the path
45865 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45866 # take no chances and rewrite it.
45867 # Note: m4 eats our [], so we need to use [ and ] instead.
45868 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45869 if test "x$has_forbidden_chars" != x; then
45870 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45871 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45872 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45873 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45874 # Going to short mode and back again did indeed matter. Since short mode is
45875 # case insensitive, let's make it lowercase to improve readability.
45876 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45877 # Now convert it back to Unix-stile (cygpath)
45878 input_path=`$CYGPATH -u "$shortmode_path"`
45879 new_path="$input_path"
45880 fi
45881 fi
45882
45883 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45884 if test "x$test_cygdrive_prefix" = x; then
45885 # As a simple fix, exclude /usr/bin since it's not a real path.
45886 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45887 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45888 # a path prefixed by /cygdrive for fixpath to work.
45889 new_path="$CYGWIN_ROOT_PATH$input_path"
45890 fi
45891 fi
45892
45893
45894 if test "x$path" != "x$new_path"; then
45895 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45896 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45897 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46026 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
46027 fi
46028
46029 # Call helper function which possibly converts this using DOS-style short mode.
46030 # If so, the updated path is stored in $new_path.
46031
46032 input_path="$new_path"
46033 # Check if we need to convert this using DOS-style short mode. If the path
46034 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46035 # take no chances and rewrite it.
46036 # Note: m4 eats our [], so we need to use [ and ] instead.
46037 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46038 if test "x$has_forbidden_chars" != x; then
46039 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46040 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46041 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46042 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46043 # Going to short mode and back again did indeed matter. Since short mode is
46044 # case insensitive, let's make it lowercase to improve readability.
46045 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46046 # Now convert it back to Unix-stile (cygpath)
46047 input_path=`$CYGPATH -u "$shortmode_path"`
46048 new_path="$input_path"
46049 fi
46050 fi
46051
46052 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46053 if test "x$test_cygdrive_prefix" = x; then
46054 # As a simple fix, exclude /usr/bin since it's not a real path.
46055 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46056 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46057 # a path prefixed by /cygdrive for fixpath to work.
46058 new_path="$CYGWIN_ROOT_PATH$input_path"
46059 fi
46060 fi
46061
46062
46063 if test "x$path" != "x$new_path"; then
46064 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46065 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46066 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46148 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
46149 fi
46150
46151 # Call helper function which possibly converts this using DOS-style short mode.
46152 # If so, the updated path is stored in $new_path.
46153
46154 input_path="$new_path"
46155 # Check if we need to convert this using DOS-style short mode. If the path
46156 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46157 # take no chances and rewrite it.
46158 # Note: m4 eats our [], so we need to use [ and ] instead.
46159 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46160 if test "x$has_forbidden_chars" != x; then
46161 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46162 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46163 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46164 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46165 # Going to short mode and back again did indeed matter. Since short mode is
46166 # case insensitive, let's make it lowercase to improve readability.
46167 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46168 # Now convert it back to Unix-stile (cygpath)
46169 input_path=`$CYGPATH -u "$shortmode_path"`
46170 new_path="$input_path"
46171 fi
46172 fi
46173
46174 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46175 if test "x$test_cygdrive_prefix" = x; then
46176 # As a simple fix, exclude /usr/bin since it's not a real path.
46177 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46178 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46179 # a path prefixed by /cygdrive for fixpath to work.
46180 new_path="$CYGWIN_ROOT_PATH$input_path"
46181 fi
46182 fi
46183
46184
46185 if test "x$path" != "x$new_path"; then
46186 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46187 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46188 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46317 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
46318 fi
46319
46320 # Call helper function which possibly converts this using DOS-style short mode.
46321 # If so, the updated path is stored in $new_path.
46322
46323 input_path="$new_path"
46324 # Check if we need to convert this using DOS-style short mode. If the path
46325 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46326 # take no chances and rewrite it.
46327 # Note: m4 eats our [], so we need to use [ and ] instead.
46328 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46329 if test "x$has_forbidden_chars" != x; then
46330 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46331 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46332 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46333 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46334 # Going to short mode and back again did indeed matter. Since short mode is
46335 # case insensitive, let's make it lowercase to improve readability.
46336 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46337 # Now convert it back to Unix-stile (cygpath)
46338 input_path=`$CYGPATH -u "$shortmode_path"`
46339 new_path="$input_path"
46340 fi
46341 fi
46342
46343 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46344 if test "x$test_cygdrive_prefix" = x; then
46345 # As a simple fix, exclude /usr/bin since it's not a real path.
46346 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46347 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46348 # a path prefixed by /cygdrive for fixpath to work.
46349 new_path="$CYGWIN_ROOT_PATH$input_path"
46350 fi
46351 fi
46352
46353
46354 if test "x$path" != "x$new_path"; then
46355 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46356 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46357 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46439 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
46440 fi
46441
46442 # Call helper function which possibly converts this using DOS-style short mode.
46443 # If so, the updated path is stored in $new_path.
46444
46445 input_path="$new_path"
46446 # Check if we need to convert this using DOS-style short mode. If the path
46447 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46448 # take no chances and rewrite it.
46449 # Note: m4 eats our [], so we need to use [ and ] instead.
46450 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46451 if test "x$has_forbidden_chars" != x; then
46452 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46453 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46454 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46455 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46456 # Going to short mode and back again did indeed matter. Since short mode is
46457 # case insensitive, let's make it lowercase to improve readability.
46458 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46459 # Now convert it back to Unix-stile (cygpath)
46460 input_path=`$CYGPATH -u "$shortmode_path"`
46461 new_path="$input_path"
46462 fi
46463 fi
46464
46465 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46466 if test "x$test_cygdrive_prefix" = x; then
46467 # As a simple fix, exclude /usr/bin since it's not a real path.
46468 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46469 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46470 # a path prefixed by /cygdrive for fixpath to work.
46471 new_path="$CYGWIN_ROOT_PATH$input_path"
46472 fi
46473 fi
46474
46475
46476 if test "x$path" != "x$new_path"; then
46477 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46478 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46479 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46617 as_fn_error $? "Cannot locate the the path of FREETYPE_INCLUDE_PATH" "$LINENO" 5
46618 fi
46619
46620 # Call helper function which possibly converts this using DOS-style short mode.
46621 # If so, the updated path is stored in $new_path.
46622
46623 input_path="$new_path"
46624 # Check if we need to convert this using DOS-style short mode. If the path
46625 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46626 # take no chances and rewrite it.
46627 # Note: m4 eats our [], so we need to use [ and ] instead.
46628 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46629 if test "x$has_forbidden_chars" != x; then
46630 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46631 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46632 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46633 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46634 # Going to short mode and back again did indeed matter. Since short mode is
46635 # case insensitive, let's make it lowercase to improve readability.
46636 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46637 # Now convert it back to Unix-stile (cygpath)
46638 input_path=`$CYGPATH -u "$shortmode_path"`
46639 new_path="$input_path"
46640 fi
46641 fi
46642
46643 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46644 if test "x$test_cygdrive_prefix" = x; then
46645 # As a simple fix, exclude /usr/bin since it's not a real path.
46646 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46647 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46648 # a path prefixed by /cygdrive for fixpath to work.
46649 new_path="$CYGWIN_ROOT_PATH$input_path"
46650 fi
46651 fi
46652
46653
46654 if test "x$path" != "x$new_path"; then
46655 FREETYPE_INCLUDE_PATH="$new_path"
46656 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46657 $as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46747 as_fn_error $? "Cannot locate the the path of FREETYPE_LIB_PATH" "$LINENO" 5
46748 fi
46749
46750 # Call helper function which possibly converts this using DOS-style short mode.
46751 # If so, the updated path is stored in $new_path.
46752
46753 input_path="$new_path"
46754 # Check if we need to convert this using DOS-style short mode. If the path
46755 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46756 # take no chances and rewrite it.
46757 # Note: m4 eats our [], so we need to use [ and ] instead.
46758 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46759 if test "x$has_forbidden_chars" != x; then
46760 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46761 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46762 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46763 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46764 # Going to short mode and back again did indeed matter. Since short mode is
46765 # case insensitive, let's make it lowercase to improve readability.
46766 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46767 # Now convert it back to Unix-stile (cygpath)
46768 input_path=`$CYGPATH -u "$shortmode_path"`
46769 new_path="$input_path"
46770 fi
46771 fi
46772
46773 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46774 if test "x$test_cygdrive_prefix" = x; then
46775 # As a simple fix, exclude /usr/bin since it's not a real path.
46776 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46777 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46778 # a path prefixed by /cygdrive for fixpath to work.
46779 new_path="$CYGWIN_ROOT_PATH$input_path"
46780 fi
46781 fi
46782
46783
46784 if test "x$path" != "x$new_path"; then
46785 FREETYPE_LIB_PATH="$new_path"
46786 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
46787 $as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47998 # TODO better (platform agnostic) test
47999 if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$TOOLCHAIN_TYPE" = xgcc; then
48000 LIBCXX="-lstdc++"
48001 fi
48002
48003
48004
48005
48006 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
48007
48008
48009 # Check whether --with-msvcr-dll was given.
48010 if test "${with_msvcr_dll+set}" = set; then :
48011 withval=$with_msvcr_dll;
48012 fi
48013
48014
48015 if test "x$with_msvcr_dll" != x; then
48016 # If given explicitely by user, do not probe. If not present, fail directly.
48017
48018 DLL_NAME="$DLL_NAME"
48019 POSSIBLE_MSVC_DLL="$with_msvcr_dll"
48020 METHOD="--with-msvcr-dll"
48021 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48022 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48023 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48024
48025 # Need to check if the found msvcr is correct architecture
48026 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48027 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48028 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48029 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48030 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48031 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48032 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48033 CORRECT_MSVCR_ARCH="PE32 executable"
48034 else
48035 CORRECT_MSVCR_ARCH="PE32+ executable"
48036 fi
48037 else
48038 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48039 CORRECT_MSVCR_ARCH=386
48040 else
48041 CORRECT_MSVCR_ARCH=x86-64
48042 fi
48043 fi
48044 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48045 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48046 $as_echo "ok" >&6; }
48047 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48048 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48049 $as_echo_n "checking for $DLL_NAME... " >&6; }
48050 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48051 $as_echo "$MSVC_DLL" >&6; }
48052 else
48053 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48054 $as_echo "incorrect, ignoring" >&6; }
48055 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48056 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48057 fi
48058 fi
48059
48060 if test "x$MSVC_DLL" = x; then
48061 as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5
48062 fi
48063 else
48064
48065 VAR_NAME="MSVCR_DLL"
48066 DLL_NAME="${MSVCR_NAME}"
48067 MSVC_DLL=
48068
48069 if test "x$MSVC_DLL" = x; then
48070 # Probe: Using well-known location from Visual Studio 10.0
48071 if test "x$VCINSTALLDIR" != x; then
48072 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
48073
48074 windows_path="$CYGWIN_VC_INSTALL_DIR"
48075 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48076 unix_path=`$CYGPATH -u "$windows_path"`
48077 CYGWIN_VC_INSTALL_DIR="$unix_path"
48078 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48079 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48080 CYGWIN_VC_INSTALL_DIR="$unix_path"
48081 fi
48082
48083 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48084 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
48085 else
48086 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
48087 fi
48088 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
48089
48090 DLL_NAME="$DLL_NAME"
48091 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48092 METHOD="well-known location in VCINSTALLDIR"
48093 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48094 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48095 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48096
48097 # Need to check if the found msvcr is correct architecture
48098 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48099 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48100 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48101 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48102 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48103 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48104 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48105 CORRECT_MSVCR_ARCH="PE32 executable"
48106 else
48107 CORRECT_MSVCR_ARCH="PE32+ executable"
48108 fi
48109 else
48110 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48111 CORRECT_MSVCR_ARCH=386
48112 else
48113 CORRECT_MSVCR_ARCH=x86-64
48114 fi
48115 fi
48116 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48117 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48118 $as_echo "ok" >&6; }
48119 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48120 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48121 $as_echo_n "checking for $DLL_NAME... " >&6; }
48122 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48123 $as_echo "$MSVC_DLL" >&6; }
48124 else
48125 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48126 $as_echo "incorrect, ignoring" >&6; }
48127 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48128 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48129 fi
48130 fi
48131
48132 fi
48133 fi
48134
48135 if test "x$MSVC_DLL" = x; then
48136 # Probe: Check in the Boot JDK directory.
48137 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
48138
48139 DLL_NAME="$DLL_NAME"
48140 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48141 METHOD="well-known location in Boot JDK"
48142 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48143 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48144 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48145
48146 # Need to check if the found msvcr is correct architecture
48147 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48148 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48149 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48150 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48151 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48152 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48153 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48154 CORRECT_MSVCR_ARCH="PE32 executable"
48155 else
48156 CORRECT_MSVCR_ARCH="PE32+ executable"
48157 fi
48158 else
48159 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48160 CORRECT_MSVCR_ARCH=386
48161 else
48162 CORRECT_MSVCR_ARCH=x86-64
48163 fi
48164 fi
48165 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48166 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48167 $as_echo "ok" >&6; }
48168 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48169 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48170 $as_echo_n "checking for $DLL_NAME... " >&6; }
48171 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48172 $as_echo "$MSVC_DLL" >&6; }
48173 else
48174 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48175 $as_echo "incorrect, ignoring" >&6; }
48176 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48177 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48178 fi
48179 fi
48180
48181 fi
48182
48183 if test "x$MSVC_DLL" = x; then
48184 # Probe: Look in the Windows system32 directory
48185 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
48186
48187 windows_path="$CYGWIN_SYSTEMROOT"
48188 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48189 unix_path=`$CYGPATH -u "$windows_path"`
48190 CYGWIN_SYSTEMROOT="$unix_path"
48191 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48192 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48193 CYGWIN_SYSTEMROOT="$unix_path"
48194 fi
48195
48196 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
48197
48198 DLL_NAME="$DLL_NAME"
48199 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48200 METHOD="well-known location in SYSTEMROOT"
48201 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48202 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48203 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48204
48205 # Need to check if the found msvcr is correct architecture
48206 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48207 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48208 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48209 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48210 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48211 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48212 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48213 CORRECT_MSVCR_ARCH="PE32 executable"
48214 else
48215 CORRECT_MSVCR_ARCH="PE32+ executable"
48216 fi
48217 else
48218 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48219 CORRECT_MSVCR_ARCH=386
48220 else
48221 CORRECT_MSVCR_ARCH=x86-64
48222 fi
48223 fi
48224 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48226 $as_echo "ok" >&6; }
48227 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48229 $as_echo_n "checking for $DLL_NAME... " >&6; }
48230 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48231 $as_echo "$MSVC_DLL" >&6; }
48232 else
48233 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48234 $as_echo "incorrect, ignoring" >&6; }
48235 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48236 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48237 fi
48238 fi
48239
48240 fi
48241
48242 if test "x$MSVC_DLL" = x; then
48243 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
48244 if test "x$VS100COMNTOOLS" != x; then
48245 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
48246
48247 windows_path="$CYGWIN_VS_TOOLS_DIR"
48248 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48249 unix_path=`$CYGPATH -u "$windows_path"`
48250 CYGWIN_VS_TOOLS_DIR="$unix_path"
48251 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48252 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48253 CYGWIN_VS_TOOLS_DIR="$unix_path"
48254 fi
48255
48256 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48257 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
48258 | $GREP -i /x64/ | $HEAD --lines 1`
48259 else
48260 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
48261 | $GREP -i /x86/ | $HEAD --lines 1`
48262 fi
48263
48264 DLL_NAME="$DLL_NAME"
48265 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48266 METHOD="search of VS100COMNTOOLS"
48267 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48268 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48269 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48270
48271 # Need to check if the found msvcr is correct architecture
48272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48273 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48274 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48275 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48276 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48277 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48278 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48279 CORRECT_MSVCR_ARCH="PE32 executable"
48280 else
48281 CORRECT_MSVCR_ARCH="PE32+ executable"
48282 fi
48283 else
48284 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48285 CORRECT_MSVCR_ARCH=386
48286 else
48287 CORRECT_MSVCR_ARCH=x86-64
48288 fi
48289 fi
48290 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48291 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48292 $as_echo "ok" >&6; }
48293 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48294 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48295 $as_echo_n "checking for $DLL_NAME... " >&6; }
48296 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48297 $as_echo "$MSVC_DLL" >&6; }
48298 else
48299 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48300 $as_echo "incorrect, ignoring" >&6; }
48301 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48302 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48303 fi
48304 fi
48305
48306 fi
48307 fi
48308
48309 if test "x$MSVC_DLL" = x; then
48310 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
48311 # (This was the original behaviour; kept since it might turn something up)
48312 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
48313 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48314 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
48315 | $GREP x64 | $HEAD --lines 1`
48316 else
48317 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
48318 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
48319 if test "x$POSSIBLE_MSVC_DLL" = x; then
48320 # We're grasping at straws now...
48321 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
48322 | $HEAD --lines 1`
48323 fi
48324 fi
48325
48326
48327 DLL_NAME="$DLL_NAME"
48328 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48329 METHOD="search of VCINSTALLDIR"
48330 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48331 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48332 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48333
48334 # Need to check if the found msvcr is correct architecture
48335 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48336 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48337 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48338 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48339 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48340 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48341 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48342 CORRECT_MSVCR_ARCH="PE32 executable"
48343 else
48344 CORRECT_MSVCR_ARCH="PE32+ executable"
48345 fi
48346 else
48347 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48348 CORRECT_MSVCR_ARCH=386
48349 else
48350 CORRECT_MSVCR_ARCH=x86-64
48351 fi
48352 fi
48353 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48354 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48355 $as_echo "ok" >&6; }
48356 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48357 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48358 $as_echo_n "checking for $DLL_NAME... " >&6; }
48359 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48360 $as_echo "$MSVC_DLL" >&6; }
48361 else
48362 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48363 $as_echo "incorrect, ignoring" >&6; }
48364 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48365 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48366 fi
48367 fi
48368
48369 fi
48370 fi
48371
48372 if test "x$MSVC_DLL" = x; then
48373 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48374 $as_echo_n "checking for $DLL_NAME... " >&6; }
48375 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
48376 $as_echo "no" >&6; }
48377 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
48378 fi
48379
48380 MSVCR_DLL=$MSVC_DLL
48381
48382 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48383
48384 # Input might be given as Windows format, start by converting to
48385 # unix format.
48386 path="$MSVCR_DLL"
48387 new_path=`$CYGPATH -u "$path"`
48388
48389 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48390 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48391 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48392 # "foo.exe" is OK but "foo" is an error.
48393 #
48394 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48395 # It is also a way to make sure we got the proper file name for the real test later on.
48396 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48397 if test "x$test_shortpath" = x; then
48398 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
48399 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
48400 as_fn_error $? "Cannot locate the the path of MSVCR_DLL" "$LINENO" 5
48401 fi
48402
48403 # Call helper function which possibly converts this using DOS-style short mode.
48404 # If so, the updated path is stored in $new_path.
48405
48406 input_path="$new_path"
48407 # Check if we need to convert this using DOS-style short mode. If the path
48408 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48409 # take no chances and rewrite it.
48410 # Note: m4 eats our [], so we need to use [ and ] instead.
48411 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48412 if test "x$has_forbidden_chars" != x; then
48413 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48414 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48415 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48416 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48417 # Going to short mode and back again did indeed matter. Since short mode is
48418 # case insensitive, let's make it lowercase to improve readability.
48419 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48420 # Now convert it back to Unix-stile (cygpath)
48421 input_path=`$CYGPATH -u "$shortmode_path"`
48422 new_path="$input_path"
48423 fi
48424 fi
48425
48426 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48427 if test "x$test_cygdrive_prefix" = x; then
48428 # As a simple fix, exclude /usr/bin since it's not a real path.
48429 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48430 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48431 # a path prefixed by /cygdrive for fixpath to work.
48432 new_path="$CYGWIN_ROOT_PATH$input_path"
48433 fi
48434 fi
48435
48436
48437 if test "x$path" != "x$new_path"; then
48438 MSVCR_DLL="$new_path"
48439 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5
48440 $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;}
48441 fi
48442
48443 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48444
48445 path="$MSVCR_DLL"
48446 has_colon=`$ECHO $path | $GREP ^.:`
48447 new_path="$path"
48448 if test "x$has_colon" = x; then
48449 # Not in mixed or Windows style, start by that.
48450 new_path=`cmd //c echo $path`
48451 fi
48452
48453
48454 input_path="$new_path"
48455 # Check if we need to convert this using DOS-style short mode. If the path
48456 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48457 # take no chances and rewrite it.
48458 # Note: m4 eats our [], so we need to use [ and ] instead.
48459 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48460 if test "x$has_forbidden_chars" != x; then
48461 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48462 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48463 fi
48464
48465
48466 windows_path="$new_path"
48467 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48468 unix_path=`$CYGPATH -u "$windows_path"`
48469 new_path="$unix_path"
48470 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48471 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48472 new_path="$unix_path"
48473 fi
48474
48475 if test "x$path" != "x$new_path"; then
48476 MSVCR_DLL="$new_path"
48477 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5
48478 $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;}
48479 fi
48480
48481 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48482 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48483
48484 else
48485 # We're on a posix platform. Hooray! :)
48486 path="$MSVCR_DLL"
48487 has_space=`$ECHO "$path" | $GREP " "`
48488 if test "x$has_space" != x; then
48489 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
48490 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
48491 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48492 fi
48493
48494 # Use eval to expand a potential ~
48495 eval path="$path"
48496 if test ! -f "$path" && test ! -d "$path"; then
48497 as_fn_error $? "The path of MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48498 fi
48499
48500 MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`"
48501 fi
48502
48503 MSVCR_DLL=$MSVCR_DLL
48504
48505
48506 fi
48507
48508
48509 # Check whether --with-msvcp-dll was given.
48510 if test "${with_msvcp_dll+set}" = set; then :
48511 withval=$with_msvcp_dll;
48512 fi
48513
48514
48515 if test "x$MSVCP_NAME" != "x"; then
48516 if test "x$with_msvcp_dll" != x; then
48517 # If given explicitely by user, do not probe. If not present, fail directly.
48518
48519 DLL_NAME="$DLL_NAME"
48520 POSSIBLE_MSVC_DLL="$with_msvcp_dll"
48521 METHOD="--with-msvcp-dll"
48522 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48523 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48524 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48525
48526 # Need to check if the found msvcr is correct architecture
48527 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48528 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48529 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48530 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48531 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48532 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48533 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48534 CORRECT_MSVCR_ARCH="PE32 executable"
48535 else
48536 CORRECT_MSVCR_ARCH="PE32+ executable"
48537 fi
48538 else
48539 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48540 CORRECT_MSVCR_ARCH=386
48541 else
48542 CORRECT_MSVCR_ARCH=x86-64
48543 fi
48544 fi
48545 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48546 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48547 $as_echo "ok" >&6; }
48548 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48550 $as_echo_n "checking for $DLL_NAME... " >&6; }
48551 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48552 $as_echo "$MSVC_DLL" >&6; }
48553 else
48554 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48555 $as_echo "incorrect, ignoring" >&6; }
48556 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48557 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48558 fi
48559 fi
48560
48561 if test "x$MSVC_DLL" = x; then
48562 as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5
48563 fi
48564 else
48565
48566 VAR_NAME="MSVCP_DLL"
48567 DLL_NAME="${MSVCP_NAME}"
48568 MSVC_DLL=
48569
48570 if test "x$MSVC_DLL" = x; then
48571 # Probe: Using well-known location from Visual Studio 10.0
48572 if test "x$VCINSTALLDIR" != x; then
48573 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
48574
48575 windows_path="$CYGWIN_VC_INSTALL_DIR"
48576 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48577 unix_path=`$CYGPATH -u "$windows_path"`
48578 CYGWIN_VC_INSTALL_DIR="$unix_path"
48579 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48580 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48581 CYGWIN_VC_INSTALL_DIR="$unix_path"
48582 fi
48583
48584 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48585 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
48586 else
48587 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
48588 fi
48589 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
48590
48601 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48602 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48603 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48604 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48605 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48606 CORRECT_MSVCR_ARCH="PE32 executable"
48607 else
48608 CORRECT_MSVCR_ARCH="PE32+ executable"
48609 fi
48610 else
48611 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48612 CORRECT_MSVCR_ARCH=386
48613 else
48614 CORRECT_MSVCR_ARCH=x86-64
48615 fi
48616 fi
48617 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48619 $as_echo "ok" >&6; }
48620 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48621 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48622 $as_echo_n "checking for $DLL_NAME... " >&6; }
48623 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48624 $as_echo "$MSVC_DLL" >&6; }
48625 else
48626 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48627 $as_echo "incorrect, ignoring" >&6; }
48628 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48629 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48630 fi
48631 fi
48632
48633 fi
48634 fi
48635
48636 if test "x$MSVC_DLL" = x; then
48637 # Probe: Check in the Boot JDK directory.
48638 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
48639
48640 DLL_NAME="$DLL_NAME"
48650 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48651 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48652 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48653 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48654 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48655 CORRECT_MSVCR_ARCH="PE32 executable"
48656 else
48657 CORRECT_MSVCR_ARCH="PE32+ executable"
48658 fi
48659 else
48660 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48661 CORRECT_MSVCR_ARCH=386
48662 else
48663 CORRECT_MSVCR_ARCH=x86-64
48664 fi
48665 fi
48666 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48667 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48668 $as_echo "ok" >&6; }
48669 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48671 $as_echo_n "checking for $DLL_NAME... " >&6; }
48672 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48673 $as_echo "$MSVC_DLL" >&6; }
48674 else
48675 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48676 $as_echo "incorrect, ignoring" >&6; }
48677 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48678 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48679 fi
48680 fi
48681
48682 fi
48683
48684 if test "x$MSVC_DLL" = x; then
48685 # Probe: Look in the Windows system32 directory
48686 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
48687
48688 windows_path="$CYGWIN_SYSTEMROOT"
48689 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48709 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48710 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48711 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48712 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48713 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48714 CORRECT_MSVCR_ARCH="PE32 executable"
48715 else
48716 CORRECT_MSVCR_ARCH="PE32+ executable"
48717 fi
48718 else
48719 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48720 CORRECT_MSVCR_ARCH=386
48721 else
48722 CORRECT_MSVCR_ARCH=x86-64
48723 fi
48724 fi
48725 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48726 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48727 $as_echo "ok" >&6; }
48728 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48729 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48730 $as_echo_n "checking for $DLL_NAME... " >&6; }
48731 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48732 $as_echo "$MSVC_DLL" >&6; }
48733 else
48734 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48735 $as_echo "incorrect, ignoring" >&6; }
48736 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48737 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48738 fi
48739 fi
48740
48741 fi
48742
48743 if test "x$MSVC_DLL" = x; then
48744 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
48745 if test "x$VS100COMNTOOLS" != x; then
48746 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
48747
48748 windows_path="$CYGWIN_VS_TOOLS_DIR"
48775 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48776 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48777 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48778 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48779 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48780 CORRECT_MSVCR_ARCH="PE32 executable"
48781 else
48782 CORRECT_MSVCR_ARCH="PE32+ executable"
48783 fi
48784 else
48785 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48786 CORRECT_MSVCR_ARCH=386
48787 else
48788 CORRECT_MSVCR_ARCH=x86-64
48789 fi
48790 fi
48791 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48792 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48793 $as_echo "ok" >&6; }
48794 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48795 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48796 $as_echo_n "checking for $DLL_NAME... " >&6; }
48797 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48798 $as_echo "$MSVC_DLL" >&6; }
48799 else
48800 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48801 $as_echo "incorrect, ignoring" >&6; }
48802 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48803 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48804 fi
48805 fi
48806
48807 fi
48808 fi
48809
48810 if test "x$MSVC_DLL" = x; then
48811 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
48812 # (This was the original behaviour; kept since it might turn something up)
48813 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
48814 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48838 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48839 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48840 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48841 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48842 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48843 CORRECT_MSVCR_ARCH="PE32 executable"
48844 else
48845 CORRECT_MSVCR_ARCH="PE32+ executable"
48846 fi
48847 else
48848 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48849 CORRECT_MSVCR_ARCH=386
48850 else
48851 CORRECT_MSVCR_ARCH=x86-64
48852 fi
48853 fi
48854 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48855 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48856 $as_echo "ok" >&6; }
48857 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48859 $as_echo_n "checking for $DLL_NAME... " >&6; }
48860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48861 $as_echo "$MSVC_DLL" >&6; }
48862 else
48863 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48864 $as_echo "incorrect, ignoring" >&6; }
48865 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48866 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48867 fi
48868 fi
48869
48870 fi
48871 fi
48872
48873 if test "x$MSVC_DLL" = x; then
48874 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48875 $as_echo_n "checking for $DLL_NAME... " >&6; }
48876 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
48877 $as_echo "no" >&6; }
48878 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
48879 fi
48880
48881 MSVCP_DLL=$MSVC_DLL
48882
48883 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48884
48885 # Input might be given as Windows format, start by converting to
48886 # unix format.
48887 path="$MSVCP_DLL"
48888 new_path=`$CYGPATH -u "$path"`
48889
48890 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48891 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48892 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48893 # "foo.exe" is OK but "foo" is an error.
48894 #
48895 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48896 # It is also a way to make sure we got the proper file name for the real test later on.
48897 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48898 if test "x$test_shortpath" = x; then
48899 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5
48900 $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;}
48901 as_fn_error $? "Cannot locate the the path of MSVCP_DLL" "$LINENO" 5
48902 fi
48903
48904 # Call helper function which possibly converts this using DOS-style short mode.
48905 # If so, the updated path is stored in $new_path.
48906
48907 input_path="$new_path"
48908 # Check if we need to convert this using DOS-style short mode. If the path
48909 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48910 # take no chances and rewrite it.
48911 # Note: m4 eats our [], so we need to use [ and ] instead.
48912 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48913 if test "x$has_forbidden_chars" != x; then
48914 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48915 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48916 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48917 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48918 # Going to short mode and back again did indeed matter. Since short mode is
48919 # case insensitive, let's make it lowercase to improve readability.
48920 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48921 # Now convert it back to Unix-stile (cygpath)
48922 input_path=`$CYGPATH -u "$shortmode_path"`
48923 new_path="$input_path"
48924 fi
48925 fi
48926
48927 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48928 if test "x$test_cygdrive_prefix" = x; then
48929 # As a simple fix, exclude /usr/bin since it's not a real path.
48930 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48931 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48932 # a path prefixed by /cygdrive for fixpath to work.
48933 new_path="$CYGWIN_ROOT_PATH$input_path"
48934 fi
48935 fi
48936
48937
48938 if test "x$path" != "x$new_path"; then
48939 MSVCP_DLL="$new_path"
48940 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5
48941 $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;}
48942 fi
48943
48944 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48945
48946 path="$MSVCP_DLL"
48947 has_colon=`$ECHO $path | $GREP ^.:`
48948 new_path="$path"
48949 if test "x$has_colon" = x; then
48950 # Not in mixed or Windows style, start by that.
48951 new_path=`cmd //c echo $path`
48952 fi
48953
48954
48955 input_path="$new_path"
48956 # Check if we need to convert this using DOS-style short mode. If the path
48957 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48958 # take no chances and rewrite it.
48959 # Note: m4 eats our [], so we need to use [ and ] instead.
48960 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48961 if test "x$has_forbidden_chars" != x; then
48962 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48963 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48964 fi
48965
48966
48967 windows_path="$new_path"
48968 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48969 unix_path=`$CYGPATH -u "$windows_path"`
48970 new_path="$unix_path"
48971 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48972 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48973 new_path="$unix_path"
48974 fi
48975
48976 if test "x$path" != "x$new_path"; then
48977 MSVCP_DLL="$new_path"
48978 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCP_DLL to \"$new_path\"" >&5
48979 $as_echo "$as_me: Rewriting MSVCP_DLL to \"$new_path\"" >&6;}
48980 fi
48981
48982 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48983 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48984
48985 else
48986 # We're on a posix platform. Hooray! :)
48987 path="$MSVCP_DLL"
48988 has_space=`$ECHO "$path" | $GREP " "`
48989 if test "x$has_space" != x; then
48990 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&5
48991 $as_echo "$as_me: The path of MSVCP_DLL, which resolves as \"$path\", is invalid." >&6;}
48992 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48993 fi
48994
48995 # Use eval to expand a potential ~
48996 eval path="$path"
48997 if test ! -f "$path" && test ! -d "$path"; then
48998 as_fn_error $? "The path of MSVCP_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48999 fi
49000
49001 MSVCP_DLL="`cd "$path"; $THEPWDCMD -L`"
49002 fi
49003
49004 MSVCP_DLL=$MSVCP_DLL
49005
49006
49007 fi
49008 fi
49009
49010
49011
49012 # Check whether --with-dxsdk was given.
49013 if test "${with_dxsdk+set}" = set; then :
49014 withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
49015 $as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
49016 fi
49017
49018
49019
49020
49021 # Check whether --with-dxsdk-lib was given.
49022 if test "${with_dxsdk_lib+set}" = set; then :
49023 withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
49024 $as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
49025 fi
49026
49027
|
3387 # $2: executable name (or list of names) to look for
3388
3389
3390 # Like BASIC_PATH_PROGS but fails if no tool was found.
3391 # $1: variable to set
3392 # $2: executable name (or list of names) to look for
3393
3394
3395 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3396 # $1: variable to set
3397 # $2: autoconf macro to call to look for the special tool
3398
3399
3400 # Setup the most fundamental tools that relies on not much else to set up,
3401 # but is used by much of the early bootstrap code.
3402
3403
3404 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3405
3406
3407 # Evaluates platform specific overrides for devkit variables.
3408 # $1: Name of variable
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418 #%%% Simple tools %%%
3419
3420 # Check if we have found a usable version of make
3421 # $1: the path to a potential make binary (or empty)
3422 # $2: the description on how we found this
3423
3424
3425 # Goes looking for a usable version of GNU make.
3426
3427
3428
3429
3430
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298
4299
4300
4301
4302 # This line needs to be here, verbatim, after all includes and the dummy hook
4303 # definitions. It is replaced with custom functionality when building
4304 # custom sources.
4305 #CUSTOM_AUTOCONF_INCLUDE
4306
4307 # Do not change or remove the following line, it is needed for consistency checks:
4308 DATE_WHEN_GENERATED=1526679992
4309
4310 ###############################################################################
4311 #
4312 # Initialization / Boot-strapping
4313 #
4314 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4315 # thus it jumps back and forth, each time gaining something needed later on.
4316 #
4317 ###############################################################################
4318
4319 # If we are requested to print additional help, do that and then exit.
4320 # This must be the very first call.
4321
4322 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4323 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4324 $PRINTF "Which are valid to use depends on the build platform.\n"
4325 for toolchain in $VALID_TOOLCHAINS_all; do
4326 # Use indirect variable referencing
4327 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4328 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
14104 as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14105 fi
14106
14107 # Call helper function which possibly converts this using DOS-style short mode.
14108 # If so, the updated path is stored in $new_path.
14109
14110 input_path="$new_path"
14111 # Check if we need to convert this using DOS-style short mode. If the path
14112 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14113 # take no chances and rewrite it.
14114 # Note: m4 eats our [], so we need to use [ and ] instead.
14115 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14116 if test "x$has_forbidden_chars" != x; then
14117 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14118 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14119 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14120 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14121 # Going to short mode and back again did indeed matter. Since short mode is
14122 # case insensitive, let's make it lowercase to improve readability.
14123 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14124 # Now convert it back to Unix-style (cygpath)
14125 input_path=`$CYGPATH -u "$shortmode_path"`
14126 new_path="$input_path"
14127 fi
14128 fi
14129
14130 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14131 if test "x$test_cygdrive_prefix" = x; then
14132 # As a simple fix, exclude /usr/bin since it's not a real path.
14133 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14134 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14135 # a path prefixed by /cygdrive for fixpath to work.
14136 new_path="$CYGWIN_ROOT_PATH$input_path"
14137 fi
14138 fi
14139
14140
14141 if test "x$path" != "x$new_path"; then
14142 CURDIR="$new_path"
14143 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14144 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14226 as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14227 fi
14228
14229 # Call helper function which possibly converts this using DOS-style short mode.
14230 # If so, the updated path is stored in $new_path.
14231
14232 input_path="$new_path"
14233 # Check if we need to convert this using DOS-style short mode. If the path
14234 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14235 # take no chances and rewrite it.
14236 # Note: m4 eats our [], so we need to use [ and ] instead.
14237 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14238 if test "x$has_forbidden_chars" != x; then
14239 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14240 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14241 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14242 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14243 # Going to short mode and back again did indeed matter. Since short mode is
14244 # case insensitive, let's make it lowercase to improve readability.
14245 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14246 # Now convert it back to Unix-style (cygpath)
14247 input_path=`$CYGPATH -u "$shortmode_path"`
14248 new_path="$input_path"
14249 fi
14250 fi
14251
14252 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14253 if test "x$test_cygdrive_prefix" = x; then
14254 # As a simple fix, exclude /usr/bin since it's not a real path.
14255 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14256 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14257 # a path prefixed by /cygdrive for fixpath to work.
14258 new_path="$CYGWIN_ROOT_PATH$input_path"
14259 fi
14260 fi
14261
14262
14263 if test "x$path" != "x$new_path"; then
14264 TOPDIR="$new_path"
14265 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14266 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14713 as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14714 fi
14715
14716 # Call helper function which possibly converts this using DOS-style short mode.
14717 # If so, the updated path is stored in $new_path.
14718
14719 input_path="$new_path"
14720 # Check if we need to convert this using DOS-style short mode. If the path
14721 # contains just simple characters, use it. Otherwise (spaces, weird characters),
14722 # take no chances and rewrite it.
14723 # Note: m4 eats our [], so we need to use [ and ] instead.
14724 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14725 if test "x$has_forbidden_chars" != x; then
14726 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14727 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14728 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14729 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14730 # Going to short mode and back again did indeed matter. Since short mode is
14731 # case insensitive, let's make it lowercase to improve readability.
14732 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14733 # Now convert it back to Unix-style (cygpath)
14734 input_path=`$CYGPATH -u "$shortmode_path"`
14735 new_path="$input_path"
14736 fi
14737 fi
14738
14739 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14740 if test "x$test_cygdrive_prefix" = x; then
14741 # As a simple fix, exclude /usr/bin since it's not a real path.
14742 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14743 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14744 # a path prefixed by /cygdrive for fixpath to work.
14745 new_path="$CYGWIN_ROOT_PATH$input_path"
14746 fi
14747 fi
14748
14749
14750 if test "x$path" != "x$new_path"; then
14751 with_devkit="$new_path"
14752 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14753 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14799 path="$with_devkit"
14800 has_space=`$ECHO "$path" | $GREP " "`
14801 if test "x$has_space" != x; then
14802 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14803 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14804 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14805 fi
14806
14807 # Use eval to expand a potential ~
14808 eval path="$path"
14809 if test ! -f "$path" && test ! -d "$path"; then
14810 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14811 fi
14812
14813 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14814 fi
14815
14816 DEVKIT_ROOT="$with_devkit"
14817 # Check for a meta data info file in the root of the devkit
14818 if test -f "$DEVKIT_ROOT/devkit.info"; then
14819 . $DEVKIT_ROOT/devkit.info
14820 # This potentially sets the following:
14821 # A descriptive name of the devkit
14822
14823 if test "x$DEVKIT_NAME" = x; then
14824 eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
14825 fi
14826
14827 # Corresponds to --with-extra-path
14828
14829 if test "x$DEVKIT_EXTRA_PATH" = x; then
14830 eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
14831 fi
14832
14833 # Corresponds to --with-toolchain-path
14834
14835 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14836 eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
14837 fi
14838
14839 # Corresponds to --with-sysroot
14840
14841 if test "x$DEVKIT_SYSROOT" = x; then
14842 eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
14843 fi
14844
14845
14846 # Identifies the Visual Studio version in the devkit
14847
14848 if test "x$DEVKIT_VS_VERSION" = x; then
14849 eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
14850 fi
14851
14852 # The Visual Studio include environment variable
14853
14854 if test "x$DEVKIT_VS_INCLUDE" = x; then
14855 eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
14856 fi
14857
14858 # The Visual Studio lib environment variable
14859
14860 if test "x$DEVKIT_VS_LIB" = x; then
14861 eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
14862 fi
14863
14864 # Corresponds to --with-msvcr-dll
14865
14866 if test "x$DEVKIT_MSVCR_DLL" = x; then
14867 eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
14868 fi
14869
14870 # Corresponds to --with-msvcp-dll
14871
14872 if test "x$DEVKIT_MSVCP_DLL" = x; then
14873 eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
14874 fi
14875
14876 fi
14877
14878 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14879 $as_echo_n "checking for devkit... " >&6; }
14880 if test "x$DEVKIT_NAME" != x; then
14881 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14882 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14883 else
14884 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14885 $as_echo "$DEVKIT_ROOT" >&6; }
14886 fi
14887
14888
14889 if test "x$DEVKIT_EXTRA_PATH" != x; then
14890 if test "x$EXTRA_PATH" = x; then
14891 EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14892 else
14893 EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14894 fi
14895 fi
14896
14897
14898 # Fallback default of just /bin if DEVKIT_PATH is not defined
14899 if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14900 DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14901 fi
14902
14903 if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14904 if test "x$TOOLCHAIN_PATH" = x; then
14905 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14906 else
14907 TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14908 fi
14909 fi
14910
14911
14912 # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14913 # places for backwards compatiblity.
14914 if test "x$DEVKIT_SYSROOT" != x; then
14915 SYSROOT="$DEVKIT_SYSROOT"
14916 elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
15064 # We are running configure from outside of the src dir.
15065 # Then use the current directory as output dir!
15066 # If configuration is situated in normal build directory, just use the build
15067 # directory name as configuration name, otherwise use the complete path.
15068 if test "x${CONF_NAME}" = x; then
15069 CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15070 fi
15071 OUTPUT_ROOT="$CURDIR"
15072 { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15073 $as_echo "in current directory" >&6; }
15074
15075 # WARNING: This might be a bad thing to do. You need to be sure you want to
15076 # have a configuration in this directory. Do some sanity checks!
15077
15078 if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15079 # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15080 # other files
15081 files_present=`$LS $OUTPUT_ROOT`
15082 # Configure has already touched config.log and confdefs.h in the current dir when this check
15083 # is performed.
15084 filtered_files=`$ECHO "$files_present" \
15085 | $SED -e 's/config.log//g' \
15086 -e 's/confdefs.h//g' \
15087 -e 's/fixpath.exe//g' \
15088 -e 's/ //g' \
15089 | $TR -d '\n'`
15090 if test "x$filtered_files" != x; then
15091 { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15092 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15093 { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15094 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15095 { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15096 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15097 { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15098 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15099 { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15100 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15101 { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15102 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15103 { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15104 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15105 as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15106 fi
15107 fi
15108 fi
15133 as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15134 fi
15135
15136 # Call helper function which possibly converts this using DOS-style short mode.
15137 # If so, the updated path is stored in $new_path.
15138
15139 input_path="$new_path"
15140 # Check if we need to convert this using DOS-style short mode. If the path
15141 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15142 # take no chances and rewrite it.
15143 # Note: m4 eats our [], so we need to use [ and ] instead.
15144 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15145 if test "x$has_forbidden_chars" != x; then
15146 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15147 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15148 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15149 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15150 # Going to short mode and back again did indeed matter. Since short mode is
15151 # case insensitive, let's make it lowercase to improve readability.
15152 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15153 # Now convert it back to Unix-style (cygpath)
15154 input_path=`$CYGPATH -u "$shortmode_path"`
15155 new_path="$input_path"
15156 fi
15157 fi
15158
15159 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15160 if test "x$test_cygdrive_prefix" = x; then
15161 # As a simple fix, exclude /usr/bin since it's not a real path.
15162 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15163 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15164 # a path prefixed by /cygdrive for fixpath to work.
15165 new_path="$CYGWIN_ROOT_PATH$input_path"
15166 fi
15167 fi
15168
15169
15170 if test "x$path" != "x$new_path"; then
15171 OUTPUT_ROOT="$new_path"
15172 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15173 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15436 fi
15437
15438 # Call helper function which possibly converts this using DOS-style short mode.
15439 # If so, the updated path is stored in $new_path.
15440 new_path="$input_to_shortpath"
15441
15442 input_path="$input_to_shortpath"
15443 # Check if we need to convert this using DOS-style short mode. If the path
15444 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15445 # take no chances and rewrite it.
15446 # Note: m4 eats our [], so we need to use [ and ] instead.
15447 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15448 if test "x$has_forbidden_chars" != x; then
15449 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15450 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15451 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15452 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15453 # Going to short mode and back again did indeed matter. Since short mode is
15454 # case insensitive, let's make it lowercase to improve readability.
15455 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15456 # Now convert it back to Unix-style (cygpath)
15457 input_path=`$CYGPATH -u "$shortmode_path"`
15458 new_path="$input_path"
15459 fi
15460 fi
15461
15462 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15463 if test "x$test_cygdrive_prefix" = x; then
15464 # As a simple fix, exclude /usr/bin since it's not a real path.
15465 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15466 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15467 # a path prefixed by /cygdrive for fixpath to work.
15468 new_path="$CYGWIN_ROOT_PATH$input_path"
15469 fi
15470 fi
15471
15472 # remove trailing .exe if any
15473 new_path="${new_path/%.exe/}"
15474
15475 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15476
15809 fi
15810
15811 # Call helper function which possibly converts this using DOS-style short mode.
15812 # If so, the updated path is stored in $new_path.
15813 new_path="$input_to_shortpath"
15814
15815 input_path="$input_to_shortpath"
15816 # Check if we need to convert this using DOS-style short mode. If the path
15817 # contains just simple characters, use it. Otherwise (spaces, weird characters),
15818 # take no chances and rewrite it.
15819 # Note: m4 eats our [], so we need to use [ and ] instead.
15820 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15821 if test "x$has_forbidden_chars" != x; then
15822 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15823 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15824 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15825 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15826 # Going to short mode and back again did indeed matter. Since short mode is
15827 # case insensitive, let's make it lowercase to improve readability.
15828 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15829 # Now convert it back to Unix-style (cygpath)
15830 input_path=`$CYGPATH -u "$shortmode_path"`
15831 new_path="$input_path"
15832 fi
15833 fi
15834
15835 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15836 if test "x$test_cygdrive_prefix" = x; then
15837 # As a simple fix, exclude /usr/bin since it's not a real path.
15838 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15839 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15840 # a path prefixed by /cygdrive for fixpath to work.
15841 new_path="$CYGWIN_ROOT_PATH$input_path"
15842 fi
15843 fi
15844
15845 # remove trailing .exe if any
15846 new_path="${new_path/%.exe/}"
15847
15848 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15849
16179 fi
16180
16181 # Call helper function which possibly converts this using DOS-style short mode.
16182 # If so, the updated path is stored in $new_path.
16183 new_path="$input_to_shortpath"
16184
16185 input_path="$input_to_shortpath"
16186 # Check if we need to convert this using DOS-style short mode. If the path
16187 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16188 # take no chances and rewrite it.
16189 # Note: m4 eats our [], so we need to use [ and ] instead.
16190 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16191 if test "x$has_forbidden_chars" != x; then
16192 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16193 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16194 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16195 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16196 # Going to short mode and back again did indeed matter. Since short mode is
16197 # case insensitive, let's make it lowercase to improve readability.
16198 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16199 # Now convert it back to Unix-style (cygpath)
16200 input_path=`$CYGPATH -u "$shortmode_path"`
16201 new_path="$input_path"
16202 fi
16203 fi
16204
16205 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16206 if test "x$test_cygdrive_prefix" = x; then
16207 # As a simple fix, exclude /usr/bin since it's not a real path.
16208 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16209 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16210 # a path prefixed by /cygdrive for fixpath to work.
16211 new_path="$CYGWIN_ROOT_PATH$input_path"
16212 fi
16213 fi
16214
16215 # remove trailing .exe if any
16216 new_path="${new_path/%.exe/}"
16217
16218 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16219
16554 fi
16555
16556 # Call helper function which possibly converts this using DOS-style short mode.
16557 # If so, the updated path is stored in $new_path.
16558 new_path="$input_to_shortpath"
16559
16560 input_path="$input_to_shortpath"
16561 # Check if we need to convert this using DOS-style short mode. If the path
16562 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16563 # take no chances and rewrite it.
16564 # Note: m4 eats our [], so we need to use [ and ] instead.
16565 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16566 if test "x$has_forbidden_chars" != x; then
16567 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16568 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16569 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16570 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16571 # Going to short mode and back again did indeed matter. Since short mode is
16572 # case insensitive, let's make it lowercase to improve readability.
16573 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16574 # Now convert it back to Unix-style (cygpath)
16575 input_path=`$CYGPATH -u "$shortmode_path"`
16576 new_path="$input_path"
16577 fi
16578 fi
16579
16580 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16581 if test "x$test_cygdrive_prefix" = x; then
16582 # As a simple fix, exclude /usr/bin since it's not a real path.
16583 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16584 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16585 # a path prefixed by /cygdrive for fixpath to work.
16586 new_path="$CYGWIN_ROOT_PATH$input_path"
16587 fi
16588 fi
16589
16590 # remove trailing .exe if any
16591 new_path="${new_path/%.exe/}"
16592
16593 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16594
16923 fi
16924
16925 # Call helper function which possibly converts this using DOS-style short mode.
16926 # If so, the updated path is stored in $new_path.
16927 new_path="$input_to_shortpath"
16928
16929 input_path="$input_to_shortpath"
16930 # Check if we need to convert this using DOS-style short mode. If the path
16931 # contains just simple characters, use it. Otherwise (spaces, weird characters),
16932 # take no chances and rewrite it.
16933 # Note: m4 eats our [], so we need to use [ and ] instead.
16934 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16935 if test "x$has_forbidden_chars" != x; then
16936 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16937 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16938 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16939 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16940 # Going to short mode and back again did indeed matter. Since short mode is
16941 # case insensitive, let's make it lowercase to improve readability.
16942 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16943 # Now convert it back to Unix-style (cygpath)
16944 input_path=`$CYGPATH -u "$shortmode_path"`
16945 new_path="$input_path"
16946 fi
16947 fi
16948
16949 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16950 if test "x$test_cygdrive_prefix" = x; then
16951 # As a simple fix, exclude /usr/bin since it's not a real path.
16952 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16953 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16954 # a path prefixed by /cygdrive for fixpath to work.
16955 new_path="$CYGWIN_ROOT_PATH$input_path"
16956 fi
16957 fi
16958
16959 # remove trailing .exe if any
16960 new_path="${new_path/%.exe/}"
16961
16962 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16963
19925 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
19926 fi
19927
19928 # Call helper function which possibly converts this using DOS-style short mode.
19929 # If so, the updated path is stored in $new_path.
19930
19931 input_path="$new_path"
19932 # Check if we need to convert this using DOS-style short mode. If the path
19933 # contains just simple characters, use it. Otherwise (spaces, weird characters),
19934 # take no chances and rewrite it.
19935 # Note: m4 eats our [], so we need to use [ and ] instead.
19936 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19937 if test "x$has_forbidden_chars" != x; then
19938 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19939 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19940 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19941 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19942 # Going to short mode and back again did indeed matter. Since short mode is
19943 # case insensitive, let's make it lowercase to improve readability.
19944 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19945 # Now convert it back to Unix-style (cygpath)
19946 input_path=`$CYGPATH -u "$shortmode_path"`
19947 new_path="$input_path"
19948 fi
19949 fi
19950
19951 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19952 if test "x$test_cygdrive_prefix" = x; then
19953 # As a simple fix, exclude /usr/bin since it's not a real path.
19954 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
19955 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19956 # a path prefixed by /cygdrive for fixpath to work.
19957 new_path="$CYGWIN_ROOT_PATH$input_path"
19958 fi
19959 fi
19960
19961
19962 if test "x$path" != "x$new_path"; then
19963 BOOT_JDK="$new_path"
19964 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19965 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20257 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20258 fi
20259
20260 # Call helper function which possibly converts this using DOS-style short mode.
20261 # If so, the updated path is stored in $new_path.
20262
20263 input_path="$new_path"
20264 # Check if we need to convert this using DOS-style short mode. If the path
20265 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20266 # take no chances and rewrite it.
20267 # Note: m4 eats our [], so we need to use [ and ] instead.
20268 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20269 if test "x$has_forbidden_chars" != x; then
20270 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20271 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20272 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20273 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20274 # Going to short mode and back again did indeed matter. Since short mode is
20275 # case insensitive, let's make it lowercase to improve readability.
20276 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20277 # Now convert it back to Unix-style (cygpath)
20278 input_path=`$CYGPATH -u "$shortmode_path"`
20279 new_path="$input_path"
20280 fi
20281 fi
20282
20283 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20284 if test "x$test_cygdrive_prefix" = x; then
20285 # As a simple fix, exclude /usr/bin since it's not a real path.
20286 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20287 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20288 # a path prefixed by /cygdrive for fixpath to work.
20289 new_path="$CYGWIN_ROOT_PATH$input_path"
20290 fi
20291 fi
20292
20293
20294 if test "x$path" != "x$new_path"; then
20295 BOOT_JDK="$new_path"
20296 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20297 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20403 as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
20404 fi
20405
20406 # Call helper function which possibly converts this using DOS-style short mode.
20407 # If so, the updated path is stored in $new_path.
20408
20409 input_path="$new_path"
20410 # Check if we need to convert this using DOS-style short mode. If the path
20411 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20412 # take no chances and rewrite it.
20413 # Note: m4 eats our [], so we need to use [ and ] instead.
20414 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20415 if test "x$has_forbidden_chars" != x; then
20416 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20417 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20418 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20419 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20420 # Going to short mode and back again did indeed matter. Since short mode is
20421 # case insensitive, let's make it lowercase to improve readability.
20422 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20423 # Now convert it back to Unix-style (cygpath)
20424 input_path=`$CYGPATH -u "$shortmode_path"`
20425 new_path="$input_path"
20426 fi
20427 fi
20428
20429 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20430 if test "x$test_cygdrive_prefix" = x; then
20431 # As a simple fix, exclude /usr/bin since it's not a real path.
20432 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20433 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20434 # a path prefixed by /cygdrive for fixpath to work.
20435 new_path="$CYGWIN_ROOT_PATH$input_path"
20436 fi
20437 fi
20438
20439
20440 if test "x$path" != "x$new_path"; then
20441 JAVA_HOME_PROCESSED="$new_path"
20442 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
20443 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
20575 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20576 fi
20577
20578 # Call helper function which possibly converts this using DOS-style short mode.
20579 # If so, the updated path is stored in $new_path.
20580
20581 input_path="$new_path"
20582 # Check if we need to convert this using DOS-style short mode. If the path
20583 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20584 # take no chances and rewrite it.
20585 # Note: m4 eats our [], so we need to use [ and ] instead.
20586 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20587 if test "x$has_forbidden_chars" != x; then
20588 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20589 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20590 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20591 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20592 # Going to short mode and back again did indeed matter. Since short mode is
20593 # case insensitive, let's make it lowercase to improve readability.
20594 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20595 # Now convert it back to Unix-style (cygpath)
20596 input_path=`$CYGPATH -u "$shortmode_path"`
20597 new_path="$input_path"
20598 fi
20599 fi
20600
20601 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20602 if test "x$test_cygdrive_prefix" = x; then
20603 # As a simple fix, exclude /usr/bin since it's not a real path.
20604 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20605 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20606 # a path prefixed by /cygdrive for fixpath to work.
20607 new_path="$CYGWIN_ROOT_PATH$input_path"
20608 fi
20609 fi
20610
20611
20612 if test "x$path" != "x$new_path"; then
20613 BOOT_JDK="$new_path"
20614 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20615 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20763 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20764 fi
20765
20766 # Call helper function which possibly converts this using DOS-style short mode.
20767 # If so, the updated path is stored in $new_path.
20768
20769 input_path="$new_path"
20770 # Check if we need to convert this using DOS-style short mode. If the path
20771 # contains just simple characters, use it. Otherwise (spaces, weird characters),
20772 # take no chances and rewrite it.
20773 # Note: m4 eats our [], so we need to use [ and ] instead.
20774 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20775 if test "x$has_forbidden_chars" != x; then
20776 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20777 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20778 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20779 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20780 # Going to short mode and back again did indeed matter. Since short mode is
20781 # case insensitive, let's make it lowercase to improve readability.
20782 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20783 # Now convert it back to Unix-style (cygpath)
20784 input_path=`$CYGPATH -u "$shortmode_path"`
20785 new_path="$input_path"
20786 fi
20787 fi
20788
20789 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20790 if test "x$test_cygdrive_prefix" = x; then
20791 # As a simple fix, exclude /usr/bin since it's not a real path.
20792 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20793 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20794 # a path prefixed by /cygdrive for fixpath to work.
20795 new_path="$CYGWIN_ROOT_PATH$input_path"
20796 fi
20797 fi
20798
20799
20800 if test "x$path" != "x$new_path"; then
20801 BOOT_JDK="$new_path"
20802 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20803 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21091 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21092 fi
21093
21094 # Call helper function which possibly converts this using DOS-style short mode.
21095 # If so, the updated path is stored in $new_path.
21096
21097 input_path="$new_path"
21098 # Check if we need to convert this using DOS-style short mode. If the path
21099 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21100 # take no chances and rewrite it.
21101 # Note: m4 eats our [], so we need to use [ and ] instead.
21102 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21103 if test "x$has_forbidden_chars" != x; then
21104 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21105 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21106 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21107 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21108 # Going to short mode and back again did indeed matter. Since short mode is
21109 # case insensitive, let's make it lowercase to improve readability.
21110 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21111 # Now convert it back to Unix-style (cygpath)
21112 input_path=`$CYGPATH -u "$shortmode_path"`
21113 new_path="$input_path"
21114 fi
21115 fi
21116
21117 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21118 if test "x$test_cygdrive_prefix" = x; then
21119 # As a simple fix, exclude /usr/bin since it's not a real path.
21120 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21121 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21122 # a path prefixed by /cygdrive for fixpath to work.
21123 new_path="$CYGWIN_ROOT_PATH$input_path"
21124 fi
21125 fi
21126
21127
21128 if test "x$path" != "x$new_path"; then
21129 BOOT_JDK="$new_path"
21130 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21131 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21306 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21307 fi
21308
21309 # Call helper function which possibly converts this using DOS-style short mode.
21310 # If so, the updated path is stored in $new_path.
21311
21312 input_path="$new_path"
21313 # Check if we need to convert this using DOS-style short mode. If the path
21314 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21315 # take no chances and rewrite it.
21316 # Note: m4 eats our [], so we need to use [ and ] instead.
21317 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21318 if test "x$has_forbidden_chars" != x; then
21319 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21320 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21321 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21322 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21323 # Going to short mode and back again did indeed matter. Since short mode is
21324 # case insensitive, let's make it lowercase to improve readability.
21325 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21326 # Now convert it back to Unix-style (cygpath)
21327 input_path=`$CYGPATH -u "$shortmode_path"`
21328 new_path="$input_path"
21329 fi
21330 fi
21331
21332 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21333 if test "x$test_cygdrive_prefix" = x; then
21334 # As a simple fix, exclude /usr/bin since it's not a real path.
21335 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21336 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21337 # a path prefixed by /cygdrive for fixpath to work.
21338 new_path="$CYGWIN_ROOT_PATH$input_path"
21339 fi
21340 fi
21341
21342
21343 if test "x$path" != "x$new_path"; then
21344 BOOT_JDK="$new_path"
21345 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21346 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21486 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21487 fi
21488
21489 # Call helper function which possibly converts this using DOS-style short mode.
21490 # If so, the updated path is stored in $new_path.
21491
21492 input_path="$new_path"
21493 # Check if we need to convert this using DOS-style short mode. If the path
21494 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21495 # take no chances and rewrite it.
21496 # Note: m4 eats our [], so we need to use [ and ] instead.
21497 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21498 if test "x$has_forbidden_chars" != x; then
21499 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21500 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21501 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21502 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21503 # Going to short mode and back again did indeed matter. Since short mode is
21504 # case insensitive, let's make it lowercase to improve readability.
21505 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21506 # Now convert it back to Unix-style (cygpath)
21507 input_path=`$CYGPATH -u "$shortmode_path"`
21508 new_path="$input_path"
21509 fi
21510 fi
21511
21512 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21513 if test "x$test_cygdrive_prefix" = x; then
21514 # As a simple fix, exclude /usr/bin since it's not a real path.
21515 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21516 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21517 # a path prefixed by /cygdrive for fixpath to work.
21518 new_path="$CYGWIN_ROOT_PATH$input_path"
21519 fi
21520 fi
21521
21522
21523 if test "x$path" != "x$new_path"; then
21524 BOOT_JDK="$new_path"
21525 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21526 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21694 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21695 fi
21696
21697 # Call helper function which possibly converts this using DOS-style short mode.
21698 # If so, the updated path is stored in $new_path.
21699
21700 input_path="$new_path"
21701 # Check if we need to convert this using DOS-style short mode. If the path
21702 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21703 # take no chances and rewrite it.
21704 # Note: m4 eats our [], so we need to use [ and ] instead.
21705 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21706 if test "x$has_forbidden_chars" != x; then
21707 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21708 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21709 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21710 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21711 # Going to short mode and back again did indeed matter. Since short mode is
21712 # case insensitive, let's make it lowercase to improve readability.
21713 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21714 # Now convert it back to Unix-style (cygpath)
21715 input_path=`$CYGPATH -u "$shortmode_path"`
21716 new_path="$input_path"
21717 fi
21718 fi
21719
21720 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21721 if test "x$test_cygdrive_prefix" = x; then
21722 # As a simple fix, exclude /usr/bin since it's not a real path.
21723 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21724 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21725 # a path prefixed by /cygdrive for fixpath to work.
21726 new_path="$CYGWIN_ROOT_PATH$input_path"
21727 fi
21728 fi
21729
21730
21731 if test "x$path" != "x$new_path"; then
21732 BOOT_JDK="$new_path"
21733 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21734 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21874 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21875 fi
21876
21877 # Call helper function which possibly converts this using DOS-style short mode.
21878 # If so, the updated path is stored in $new_path.
21879
21880 input_path="$new_path"
21881 # Check if we need to convert this using DOS-style short mode. If the path
21882 # contains just simple characters, use it. Otherwise (spaces, weird characters),
21883 # take no chances and rewrite it.
21884 # Note: m4 eats our [], so we need to use [ and ] instead.
21885 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21886 if test "x$has_forbidden_chars" != x; then
21887 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21888 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21889 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21890 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21891 # Going to short mode and back again did indeed matter. Since short mode is
21892 # case insensitive, let's make it lowercase to improve readability.
21893 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21894 # Now convert it back to Unix-style (cygpath)
21895 input_path=`$CYGPATH -u "$shortmode_path"`
21896 new_path="$input_path"
21897 fi
21898 fi
21899
21900 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21901 if test "x$test_cygdrive_prefix" = x; then
21902 # As a simple fix, exclude /usr/bin since it's not a real path.
21903 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21904 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21905 # a path prefixed by /cygdrive for fixpath to work.
21906 new_path="$CYGWIN_ROOT_PATH$input_path"
21907 fi
21908 fi
21909
21910
21911 if test "x$path" != "x$new_path"; then
21912 BOOT_JDK="$new_path"
21913 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21914 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22082 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22083 fi
22084
22085 # Call helper function which possibly converts this using DOS-style short mode.
22086 # If so, the updated path is stored in $new_path.
22087
22088 input_path="$new_path"
22089 # Check if we need to convert this using DOS-style short mode. If the path
22090 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22091 # take no chances and rewrite it.
22092 # Note: m4 eats our [], so we need to use [ and ] instead.
22093 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22094 if test "x$has_forbidden_chars" != x; then
22095 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22096 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22097 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22098 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22099 # Going to short mode and back again did indeed matter. Since short mode is
22100 # case insensitive, let's make it lowercase to improve readability.
22101 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22102 # Now convert it back to Unix-style (cygpath)
22103 input_path=`$CYGPATH -u "$shortmode_path"`
22104 new_path="$input_path"
22105 fi
22106 fi
22107
22108 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22109 if test "x$test_cygdrive_prefix" = x; then
22110 # As a simple fix, exclude /usr/bin since it's not a real path.
22111 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22112 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22113 # a path prefixed by /cygdrive for fixpath to work.
22114 new_path="$CYGWIN_ROOT_PATH$input_path"
22115 fi
22116 fi
22117
22118
22119 if test "x$path" != "x$new_path"; then
22120 BOOT_JDK="$new_path"
22121 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22122 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22262 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22263 fi
22264
22265 # Call helper function which possibly converts this using DOS-style short mode.
22266 # If so, the updated path is stored in $new_path.
22267
22268 input_path="$new_path"
22269 # Check if we need to convert this using DOS-style short mode. If the path
22270 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22271 # take no chances and rewrite it.
22272 # Note: m4 eats our [], so we need to use [ and ] instead.
22273 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22274 if test "x$has_forbidden_chars" != x; then
22275 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22276 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22277 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22278 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22279 # Going to short mode and back again did indeed matter. Since short mode is
22280 # case insensitive, let's make it lowercase to improve readability.
22281 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22282 # Now convert it back to Unix-style (cygpath)
22283 input_path=`$CYGPATH -u "$shortmode_path"`
22284 new_path="$input_path"
22285 fi
22286 fi
22287
22288 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22289 if test "x$test_cygdrive_prefix" = x; then
22290 # As a simple fix, exclude /usr/bin since it's not a real path.
22291 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22292 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22293 # a path prefixed by /cygdrive for fixpath to work.
22294 new_path="$CYGWIN_ROOT_PATH$input_path"
22295 fi
22296 fi
22297
22298
22299 if test "x$path" != "x$new_path"; then
22300 BOOT_JDK="$new_path"
22301 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22302 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22470 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22471 fi
22472
22473 # Call helper function which possibly converts this using DOS-style short mode.
22474 # If so, the updated path is stored in $new_path.
22475
22476 input_path="$new_path"
22477 # Check if we need to convert this using DOS-style short mode. If the path
22478 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22479 # take no chances and rewrite it.
22480 # Note: m4 eats our [], so we need to use [ and ] instead.
22481 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22482 if test "x$has_forbidden_chars" != x; then
22483 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22484 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22485 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22486 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22487 # Going to short mode and back again did indeed matter. Since short mode is
22488 # case insensitive, let's make it lowercase to improve readability.
22489 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22490 # Now convert it back to Unix-style (cygpath)
22491 input_path=`$CYGPATH -u "$shortmode_path"`
22492 new_path="$input_path"
22493 fi
22494 fi
22495
22496 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22497 if test "x$test_cygdrive_prefix" = x; then
22498 # As a simple fix, exclude /usr/bin since it's not a real path.
22499 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22500 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22501 # a path prefixed by /cygdrive for fixpath to work.
22502 new_path="$CYGWIN_ROOT_PATH$input_path"
22503 fi
22504 fi
22505
22506
22507 if test "x$path" != "x$new_path"; then
22508 BOOT_JDK="$new_path"
22509 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22510 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22650 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22651 fi
22652
22653 # Call helper function which possibly converts this using DOS-style short mode.
22654 # If so, the updated path is stored in $new_path.
22655
22656 input_path="$new_path"
22657 # Check if we need to convert this using DOS-style short mode. If the path
22658 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22659 # take no chances and rewrite it.
22660 # Note: m4 eats our [], so we need to use [ and ] instead.
22661 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22662 if test "x$has_forbidden_chars" != x; then
22663 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22664 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22665 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22666 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22667 # Going to short mode and back again did indeed matter. Since short mode is
22668 # case insensitive, let's make it lowercase to improve readability.
22669 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22670 # Now convert it back to Unix-style (cygpath)
22671 input_path=`$CYGPATH -u "$shortmode_path"`
22672 new_path="$input_path"
22673 fi
22674 fi
22675
22676 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22677 if test "x$test_cygdrive_prefix" = x; then
22678 # As a simple fix, exclude /usr/bin since it's not a real path.
22679 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22680 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22681 # a path prefixed by /cygdrive for fixpath to work.
22682 new_path="$CYGWIN_ROOT_PATH$input_path"
22683 fi
22684 fi
22685
22686
22687 if test "x$path" != "x$new_path"; then
22688 BOOT_JDK="$new_path"
22689 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22690 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22845 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22846 fi
22847
22848 # Call helper function which possibly converts this using DOS-style short mode.
22849 # If so, the updated path is stored in $new_path.
22850
22851 input_path="$new_path"
22852 # Check if we need to convert this using DOS-style short mode. If the path
22853 # contains just simple characters, use it. Otherwise (spaces, weird characters),
22854 # take no chances and rewrite it.
22855 # Note: m4 eats our [], so we need to use [ and ] instead.
22856 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22857 if test "x$has_forbidden_chars" != x; then
22858 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22859 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22860 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22861 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22862 # Going to short mode and back again did indeed matter. Since short mode is
22863 # case insensitive, let's make it lowercase to improve readability.
22864 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22865 # Now convert it back to Unix-style (cygpath)
22866 input_path=`$CYGPATH -u "$shortmode_path"`
22867 new_path="$input_path"
22868 fi
22869 fi
22870
22871 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22872 if test "x$test_cygdrive_prefix" = x; then
22873 # As a simple fix, exclude /usr/bin since it's not a real path.
22874 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22875 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22876 # a path prefixed by /cygdrive for fixpath to work.
22877 new_path="$CYGWIN_ROOT_PATH$input_path"
22878 fi
22879 fi
22880
22881
22882 if test "x$path" != "x$new_path"; then
22883 BOOT_JDK="$new_path"
22884 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22885 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23023 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23024 fi
23025
23026 # Call helper function which possibly converts this using DOS-style short mode.
23027 # If so, the updated path is stored in $new_path.
23028
23029 input_path="$new_path"
23030 # Check if we need to convert this using DOS-style short mode. If the path
23031 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23032 # take no chances and rewrite it.
23033 # Note: m4 eats our [], so we need to use [ and ] instead.
23034 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23035 if test "x$has_forbidden_chars" != x; then
23036 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23037 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23038 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23039 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23040 # Going to short mode and back again did indeed matter. Since short mode is
23041 # case insensitive, let's make it lowercase to improve readability.
23042 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23043 # Now convert it back to Unix-style (cygpath)
23044 input_path=`$CYGPATH -u "$shortmode_path"`
23045 new_path="$input_path"
23046 fi
23047 fi
23048
23049 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23050 if test "x$test_cygdrive_prefix" = x; then
23051 # As a simple fix, exclude /usr/bin since it's not a real path.
23052 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23053 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23054 # a path prefixed by /cygdrive for fixpath to work.
23055 new_path="$CYGWIN_ROOT_PATH$input_path"
23056 fi
23057 fi
23058
23059
23060 if test "x$path" != "x$new_path"; then
23061 BOOT_JDK="$new_path"
23062 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23063 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23219 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23220 fi
23221
23222 # Call helper function which possibly converts this using DOS-style short mode.
23223 # If so, the updated path is stored in $new_path.
23224
23225 input_path="$new_path"
23226 # Check if we need to convert this using DOS-style short mode. If the path
23227 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23228 # take no chances and rewrite it.
23229 # Note: m4 eats our [], so we need to use [ and ] instead.
23230 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23231 if test "x$has_forbidden_chars" != x; then
23232 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23233 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23234 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23235 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23236 # Going to short mode and back again did indeed matter. Since short mode is
23237 # case insensitive, let's make it lowercase to improve readability.
23238 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23239 # Now convert it back to Unix-style (cygpath)
23240 input_path=`$CYGPATH -u "$shortmode_path"`
23241 new_path="$input_path"
23242 fi
23243 fi
23244
23245 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23246 if test "x$test_cygdrive_prefix" = x; then
23247 # As a simple fix, exclude /usr/bin since it's not a real path.
23248 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23249 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23250 # a path prefixed by /cygdrive for fixpath to work.
23251 new_path="$CYGWIN_ROOT_PATH$input_path"
23252 fi
23253 fi
23254
23255
23256 if test "x$path" != "x$new_path"; then
23257 BOOT_JDK="$new_path"
23258 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23259 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23397 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23398 fi
23399
23400 # Call helper function which possibly converts this using DOS-style short mode.
23401 # If so, the updated path is stored in $new_path.
23402
23403 input_path="$new_path"
23404 # Check if we need to convert this using DOS-style short mode. If the path
23405 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23406 # take no chances and rewrite it.
23407 # Note: m4 eats our [], so we need to use [ and ] instead.
23408 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23409 if test "x$has_forbidden_chars" != x; then
23410 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23411 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23412 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23413 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23414 # Going to short mode and back again did indeed matter. Since short mode is
23415 # case insensitive, let's make it lowercase to improve readability.
23416 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23417 # Now convert it back to Unix-style (cygpath)
23418 input_path=`$CYGPATH -u "$shortmode_path"`
23419 new_path="$input_path"
23420 fi
23421 fi
23422
23423 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23424 if test "x$test_cygdrive_prefix" = x; then
23425 # As a simple fix, exclude /usr/bin since it's not a real path.
23426 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23427 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23428 # a path prefixed by /cygdrive for fixpath to work.
23429 new_path="$CYGWIN_ROOT_PATH$input_path"
23430 fi
23431 fi
23432
23433
23434 if test "x$path" != "x$new_path"; then
23435 BOOT_JDK="$new_path"
23436 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23437 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23592 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23593 fi
23594
23595 # Call helper function which possibly converts this using DOS-style short mode.
23596 # If so, the updated path is stored in $new_path.
23597
23598 input_path="$new_path"
23599 # Check if we need to convert this using DOS-style short mode. If the path
23600 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23601 # take no chances and rewrite it.
23602 # Note: m4 eats our [], so we need to use [ and ] instead.
23603 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23604 if test "x$has_forbidden_chars" != x; then
23605 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23606 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23607 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23608 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23609 # Going to short mode and back again did indeed matter. Since short mode is
23610 # case insensitive, let's make it lowercase to improve readability.
23611 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23612 # Now convert it back to Unix-style (cygpath)
23613 input_path=`$CYGPATH -u "$shortmode_path"`
23614 new_path="$input_path"
23615 fi
23616 fi
23617
23618 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23619 if test "x$test_cygdrive_prefix" = x; then
23620 # As a simple fix, exclude /usr/bin since it's not a real path.
23621 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23622 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23623 # a path prefixed by /cygdrive for fixpath to work.
23624 new_path="$CYGWIN_ROOT_PATH$input_path"
23625 fi
23626 fi
23627
23628
23629 if test "x$path" != "x$new_path"; then
23630 BOOT_JDK="$new_path"
23631 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23632 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23770 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23771 fi
23772
23773 # Call helper function which possibly converts this using DOS-style short mode.
23774 # If so, the updated path is stored in $new_path.
23775
23776 input_path="$new_path"
23777 # Check if we need to convert this using DOS-style short mode. If the path
23778 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23779 # take no chances and rewrite it.
23780 # Note: m4 eats our [], so we need to use [ and ] instead.
23781 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23782 if test "x$has_forbidden_chars" != x; then
23783 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23784 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23785 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23786 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23787 # Going to short mode and back again did indeed matter. Since short mode is
23788 # case insensitive, let's make it lowercase to improve readability.
23789 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23790 # Now convert it back to Unix-style (cygpath)
23791 input_path=`$CYGPATH -u "$shortmode_path"`
23792 new_path="$input_path"
23793 fi
23794 fi
23795
23796 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23797 if test "x$test_cygdrive_prefix" = x; then
23798 # As a simple fix, exclude /usr/bin since it's not a real path.
23799 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23800 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23801 # a path prefixed by /cygdrive for fixpath to work.
23802 new_path="$CYGWIN_ROOT_PATH$input_path"
23803 fi
23804 fi
23805
23806
23807 if test "x$path" != "x$new_path"; then
23808 BOOT_JDK="$new_path"
23809 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23810 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23966 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23967 fi
23968
23969 # Call helper function which possibly converts this using DOS-style short mode.
23970 # If so, the updated path is stored in $new_path.
23971
23972 input_path="$new_path"
23973 # Check if we need to convert this using DOS-style short mode. If the path
23974 # contains just simple characters, use it. Otherwise (spaces, weird characters),
23975 # take no chances and rewrite it.
23976 # Note: m4 eats our [], so we need to use [ and ] instead.
23977 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23978 if test "x$has_forbidden_chars" != x; then
23979 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23980 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23981 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23982 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23983 # Going to short mode and back again did indeed matter. Since short mode is
23984 # case insensitive, let's make it lowercase to improve readability.
23985 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23986 # Now convert it back to Unix-style (cygpath)
23987 input_path=`$CYGPATH -u "$shortmode_path"`
23988 new_path="$input_path"
23989 fi
23990 fi
23991
23992 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23993 if test "x$test_cygdrive_prefix" = x; then
23994 # As a simple fix, exclude /usr/bin since it's not a real path.
23995 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23996 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23997 # a path prefixed by /cygdrive for fixpath to work.
23998 new_path="$CYGWIN_ROOT_PATH$input_path"
23999 fi
24000 fi
24001
24002
24003 if test "x$path" != "x$new_path"; then
24004 BOOT_JDK="$new_path"
24005 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24006 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24144 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24145 fi
24146
24147 # Call helper function which possibly converts this using DOS-style short mode.
24148 # If so, the updated path is stored in $new_path.
24149
24150 input_path="$new_path"
24151 # Check if we need to convert this using DOS-style short mode. If the path
24152 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24153 # take no chances and rewrite it.
24154 # Note: m4 eats our [], so we need to use [ and ] instead.
24155 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24156 if test "x$has_forbidden_chars" != x; then
24157 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24158 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24159 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24160 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24161 # Going to short mode and back again did indeed matter. Since short mode is
24162 # case insensitive, let's make it lowercase to improve readability.
24163 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24164 # Now convert it back to Unix-style (cygpath)
24165 input_path=`$CYGPATH -u "$shortmode_path"`
24166 new_path="$input_path"
24167 fi
24168 fi
24169
24170 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24171 if test "x$test_cygdrive_prefix" = x; then
24172 # As a simple fix, exclude /usr/bin since it's not a real path.
24173 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24174 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24175 # a path prefixed by /cygdrive for fixpath to work.
24176 new_path="$CYGWIN_ROOT_PATH$input_path"
24177 fi
24178 fi
24179
24180
24181 if test "x$path" != "x$new_path"; then
24182 BOOT_JDK="$new_path"
24183 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24184 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24321 as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24322 fi
24323
24324 # Call helper function which possibly converts this using DOS-style short mode.
24325 # If so, the updated path is stored in $new_path.
24326
24327 input_path="$new_path"
24328 # Check if we need to convert this using DOS-style short mode. If the path
24329 # contains just simple characters, use it. Otherwise (spaces, weird characters),
24330 # take no chances and rewrite it.
24331 # Note: m4 eats our [], so we need to use [ and ] instead.
24332 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24333 if test "x$has_forbidden_chars" != x; then
24334 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24335 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24336 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24337 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24338 # Going to short mode and back again did indeed matter. Since short mode is
24339 # case insensitive, let's make it lowercase to improve readability.
24340 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24341 # Now convert it back to Unix-style (cygpath)
24342 input_path=`$CYGPATH -u "$shortmode_path"`
24343 new_path="$input_path"
24344 fi
24345 fi
24346
24347 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24348 if test "x$test_cygdrive_prefix" = x; then
24349 # As a simple fix, exclude /usr/bin since it's not a real path.
24350 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24351 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24352 # a path prefixed by /cygdrive for fixpath to work.
24353 new_path="$CYGWIN_ROOT_PATH$input_path"
24354 fi
24355 fi
24356
24357
24358 if test "x$path" != "x$new_path"; then
24359 BOOT_JDK="$new_path"
24360 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24361 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25251 { $as_echo "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
25252 $as_echo "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
25253 fi
25254
25255
25256 # Then detect the actual binaries needed
25257
25258 # FIXME: Is this needed?
25259 ac_ext=cpp
25260 ac_cpp='$CXXCPP $CPPFLAGS'
25261 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
25262 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
25263 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
25264
25265
25266 # Store the CFLAGS etal passed to the configure script.
25267 ORG_CFLAGS="$CFLAGS"
25268 ORG_CXXFLAGS="$CXXFLAGS"
25269 ORG_OBJCFLAGS="$OBJCFLAGS"
25270
25271 # autoconf magic only relies on PATH, so update it if tools dir is specified
25272 OLD_PATH="$PATH"
25273
25274 # On Windows, we need to detect the visual studio installation first.
25275 # This will change the PATH, but we need to keep that new PATH even
25276 # after toolchain detection is done, since the compiler (on x86) uses
25277 # it for DLL resolution in runtime.
25278 if test "x$OPENJDK_BUILD_OS" = "xwindows" \
25279 && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then
25280
25281 # Store path to cygwin link.exe to help excluding it when searching for
25282 # VS linker. This must be done before changing the PATH when looking for VS.
25283 # Extract the first word of "link", so it can be a program name with args.
25284 set dummy link; ac_word=$2
25285 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
25286 $as_echo_n "checking for $ac_word... " >&6; }
25287 if ${ac_cv_path_CYGWIN_LINK+:} false; then :
25288 $as_echo_n "(cached) " >&6
25289 else
25290 case $CYGWIN_LINK in
25291 [\\/]* | ?:[\\/]*)
25292 ac_cv_path_CYGWIN_LINK="$CYGWIN_LINK" # Let the user override the test with a path.
25293 ;;
25294 *)
25295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
25296 for as_dir in $PATH
25297 do
25298 IFS=$as_save_IFS
25299 test -z "$as_dir" && as_dir=.
25337
25338 # First-hand choice is to locate and run the vsvars bat file.
25339
25340
25341 # Check whether --with-toolchain-version was given.
25342 if test "${with_toolchain_version+set}" = set; then :
25343 withval=$with_toolchain_version;
25344 fi
25345
25346
25347 if test "x$with_toolchain_version" = xlist; then
25348 # List all toolchains
25349 { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
25350 $as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
25351 for version in $VALID_VS_VERSIONS; do
25352 eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
25353 $PRINTF " %-10s %s\n" $version "$VS_DESCRIPTION"
25354 done
25355
25356 exit 0
25357 elif test "x$DEVKIT_VS_VERSION" != x; then
25358 VS_VERSION=$DEVKIT_VS_VERSION
25359 TOOLCHAIN_VERSION=$VS_VERSION
25360 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
25361 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
25362 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
25363 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
25364 eval PLATFORM_TOOLSET="\${VS_VS_PLATFORM_NAME_${VS_VERSION}}"
25365 VS_PATH="$TOOLCHAIN_PATH:$PATH"
25366
25367 # Convert DEVKIT_VS_INCLUDE into windows style VS_INCLUDE so that it
25368 # can still be exported as INCLUDE for compiler invocations without
25369 # SYSROOT_CFLAGS
25370 OLDIFS="$IFS"
25371 IFS=";"
25372 for i in $DEVKIT_VS_INCLUDE; do
25373 ipath=$i
25374
25375 unix_path="$ipath"
25376 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25377 windows_path=`$CYGPATH -m "$unix_path"`
25378 ipath="$windows_path"
25379 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25380 windows_path=`cmd //c echo $unix_path`
25381 ipath="$windows_path"
25382 fi
25383
25384 VS_INCLUDE="$VS_INCLUDE;$ipath"
25385 done
25386 # Convert DEVKIT_VS_LIB into VS_LIB so that it can still be exported
25387 # as LIB for compiler invocations without SYSROOT_LDFLAGS
25388 for i in $DEVKIT_VS_LIB; do
25389 libpath=$i
25390
25391 unix_path="$libpath"
25392 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25393 windows_path=`$CYGPATH -m "$unix_path"`
25394 libpath="$windows_path"
25395 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25396 windows_path=`cmd //c echo $unix_path`
25397 libpath="$windows_path"
25398 fi
25399
25400 VS_LIB="$VS_LIB;$libpath"
25401 done
25402 IFS="$OLDIFS"
25403
25404 { $as_echo "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
25405 $as_echo "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
25406
25407 elif test "x$with_toolchain_version" != x; then
25408 # User override; check that it is valid
25409 if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
25410 { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
25411 $as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
25412 { $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
25413 $as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
25414 as_fn_error $? "Cannot continue." "$LINENO" 5
25415 fi
25416 VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
25417 else
25418 # No flag given, use default
25419 VS_VERSIONS_PROBE_LIST="$VALID_VS_VERSIONS"
25420 fi
25421
25422 for VS_VERSION in $VS_VERSIONS_PROBE_LIST; do
25423
25424 VS_VERSION="$VS_VERSION"
25425 eval VS_COMNTOOLS_VAR="\${VS_ENVVAR_${VS_VERSION}}"
25426 eval VS_COMNTOOLS="\$${VS_COMNTOOLS_VAR}"
25959 fi
25960 fi
25961 fi
25962
25963 fi
25964
25965 if test "x$VS_ENV_CMD" != x; then
25966 TOOLCHAIN_VERSION=$VS_VERSION
25967 eval VS_DESCRIPTION="\${VS_DESCRIPTION_${VS_VERSION}}"
25968 eval VS_VERSION_INTERNAL="\${VS_VERSION_INTERNAL_${VS_VERSION}}"
25969 eval MSVCR_NAME="\${VS_MSVCR_${VS_VERSION}}"
25970 eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
25971 # The rest of the variables are already evaled while probing
25972 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
25973 $as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
25974 break
25975 fi
25976 done
25977
25978
25979 # If we have a devkit, skip all of the below.
25980 if test "x$DEVKIT_VS_VERSION" = x; then
25981 if test "x$VS_ENV_CMD" != x; then
25982 # We have found a Visual Studio environment on disk, let's extract variables from the vsvars bat file.
25983
25984 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25985
25986 # First separate the path from the arguments. This will split at the first
25987 # space.
25988 complete="$VS_ENV_CMD"
25989 path="${complete%% *}"
25990 tmp="$complete EOL"
25991 arguments="${tmp#* }"
25992
25993 # Input might be given as Windows format, start by converting to
25994 # unix format.
25995 new_path=`$CYGPATH -u "$path"`
25996
25997 # Now try to locate executable using which
25998 new_path=`$WHICH "$new_path" 2> /dev/null`
25999 # bat and cmd files are not always considered executable in cygwin causing which
26000 # to not find them
26059 fi
26060
26061 # Call helper function which possibly converts this using DOS-style short mode.
26062 # If so, the updated path is stored in $new_path.
26063 new_path="$input_to_shortpath"
26064
26065 input_path="$input_to_shortpath"
26066 # Check if we need to convert this using DOS-style short mode. If the path
26067 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26068 # take no chances and rewrite it.
26069 # Note: m4 eats our [], so we need to use [ and ] instead.
26070 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26071 if test "x$has_forbidden_chars" != x; then
26072 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26073 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26074 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26075 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26076 # Going to short mode and back again did indeed matter. Since short mode is
26077 # case insensitive, let's make it lowercase to improve readability.
26078 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26079 # Now convert it back to Unix-style (cygpath)
26080 input_path=`$CYGPATH -u "$shortmode_path"`
26081 new_path="$input_path"
26082 fi
26083 fi
26084
26085 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26086 if test "x$test_cygdrive_prefix" = x; then
26087 # As a simple fix, exclude /usr/bin since it's not a real path.
26088 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
26089 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26090 # a path prefixed by /cygdrive for fixpath to work.
26091 new_path="$CYGWIN_ROOT_PATH$input_path"
26092 fi
26093 fi
26094
26095 # remove trailing .exe if any
26096 new_path="${new_path/%.exe/}"
26097
26098 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26099
26290 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
26291 windows_path=`$CYGPATH -m "$unix_path"`
26292 WINPATH_BASH="$windows_path"
26293 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26294 windows_path=`cmd //c echo $unix_path`
26295 WINPATH_BASH="$windows_path"
26296 fi
26297
26298
26299 # Generate a DOS batch file which runs $VS_ENV_CMD, and then creates a shell
26300 # script (executable by bash) that will setup the important variables.
26301 EXTRACT_VC_ENV_BAT_FILE="$VS_ENV_TMP_DIR/extract-vs-env.bat"
26302 $ECHO "@echo off" > $EXTRACT_VC_ENV_BAT_FILE
26303 # This will end up something like:
26304 # call C:/progra~2/micros~2.0/vc/bin/amd64/vcvars64.bat
26305 $ECHO "call $WINPATH_VS_ENV_CMD $VS_ENV_ARGS" >> $EXTRACT_VC_ENV_BAT_FILE
26306 # These will end up something like:
26307 # C:/CygWin/bin/bash -c 'echo VS_PATH=\"$PATH\" > localdevenv.sh
26308 # The trailing space for everyone except PATH is no typo, but is needed due
26309 # to trailing \ in the Windows paths. These will be stripped later.
26310 $ECHO "$WINPATH_BASH -c 'echo VS_PATH="'\"$PATH\" > set-vs-env.sh'
26311 >> $EXTRACT_VC_ENV_BAT_FILE
26312 $ECHO "$WINPATH_BASH -c 'echo VS_INCLUDE="'\"$INCLUDE \" >> set-vs-env.sh' \
26313 >> $EXTRACT_VC_ENV_BAT_FILE
26314 $ECHO "$WINPATH_BASH -c 'echo VS_LIB="'\"$LIB \" >> set-vs-env.sh' \
26315 >> $EXTRACT_VC_ENV_BAT_FILE
26316 $ECHO "$WINPATH_BASH -c 'echo VCINSTALLDIR="'\"$VCINSTALLDIR \" >> set-vs-env.sh' \
26317 >> $EXTRACT_VC_ENV_BAT_FILE
26318 $ECHO "$WINPATH_BASH -c 'echo WindowsSdkDir="'\"$WindowsSdkDir \" >> set-vs-env.sh' \
26319 >> $EXTRACT_VC_ENV_BAT_FILE
26320 $ECHO "$WINPATH_BASH -c 'echo WINDOWSSDKDIR="'\"$WINDOWSSDKDIR \" >> set-vs-env.sh' \
26321 >> $EXTRACT_VC_ENV_BAT_FILE
26322
26323 # Now execute the newly created bat file.
26324 # The | cat is to stop SetEnv.Cmd to mess with system colors on msys.
26325 # Change directory so we don't need to mess with Windows paths in redirects.
26326 cd $VS_ENV_TMP_DIR
26327 cmd /c extract-vs-env.bat | $CAT
26328 cd $CURDIR
26329
26330 if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
26331 { $as_echo "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
26332 $as_echo "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
26333 { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
26334 $as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
26335 { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
26336 $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
26337 as_fn_error $? "Cannot continue" "$LINENO" 5
26338 fi
26339
26340 # Now set all paths and other env variables. This will allow the rest of
26341 # the configure script to find and run the compiler in the proper way.
26342 { $as_echo "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
26343 $as_echo "$as_me: Setting extracted environment variables" >&6;}
26344 . $VS_ENV_TMP_DIR/set-vs-env.sh
26345 # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
26346 # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
26347 else
26348 # We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
26349 { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
26350 $as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
26351 fi
26352 fi
26353
26354 # At this point, we should have correct variables in the environment, or we can't continue.
26355 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
26356 $as_echo_n "checking for Visual Studio variables... " >&6; }
26357
26358 if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \
26359 || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then
26360 if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
26361 { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
26362 $as_echo "present but broken" >&6; }
26363 as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5
26364 else
26365 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
26366 $as_echo "ok" >&6; }
26367 # Remove any trailing "\" and " " from the variables.
26368 VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED 's/\\\\* *$//'`
26369 VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\* *$//'`
26370 VCINSTALLDIR=`$ECHO "$VCINSTALLDIR" | $SED 's/\\\\* *$//'`
26371 WindowsSDKDir=`$ECHO "$WindowsSDKDir" | $SED 's/\\\\* *$//'`
26372 WINDOWSSDKDIR=`$ECHO "$WINDOWSSDKDIR" | $SED 's/\\\\* *$//'`
26373 # Remove any paths containing # (typically F#) as that messes up make. This
26374 # is needed if visual studio was installed with F# support.
26375 VS_PATH=`$ECHO "$VS_PATH" | $SED 's/[^:#]*#[^:]*://g'`
26376
26377
26378
26379
26389 $as_echo "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
26390 else
26391 { $as_echo "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
26392 $as_echo "$as_me: Running the extraction script failed." >&6;}
26393 fi
26394 { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
26395 $as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
26396 { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
26397 $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
26398 as_fn_error $? "Cannot continue" "$LINENO" 5
26399 fi
26400
26401 # Reset path to VS_PATH. It will include everything that was on PATH at the time we
26402 # ran TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV.
26403 PATH="$VS_PATH"
26404 # The microsoft toolchain also requires INCLUDE and LIB to be set.
26405 export INCLUDE="$VS_INCLUDE"
26406 export LIB="$VS_LIB"
26407 fi
26408
26409 # Before we locate the compilers, we need to sanitize the Xcode build environment
26410 if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
26411 # determine path to Xcode developer directory
26412 # can be empty in which case all the tools will rely on a sane Xcode 4 installation
26413 SET_DEVELOPER_DIR=
26414
26415 if test -n "$XCODE_PATH"; then
26416 DEVELOPER_DIR="$XCODE_PATH"/Contents/Developer
26417 fi
26418
26419 # DEVELOPER_DIR could also be provided directly
26420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking Determining if we need to set DEVELOPER_DIR" >&5
26421 $as_echo_n "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
26422 if test -n "$DEVELOPER_DIR"; then
26423 if test ! -d "$DEVELOPER_DIR"; then
26424 as_fn_error $? "Xcode Developer path does not exist: $DEVELOPER_DIR, please provide a path to the Xcode 4 application bundle using --with-xcode-path" "$LINENO" 5
26425 fi
26426 if test ! -f "$DEVELOPER_DIR"/usr/bin/xcodebuild; then
26427 as_fn_error $? "Xcode Developer path is not valid: $DEVELOPER_DIR, it must point to Contents/Developer inside an Xcode application bundle" "$LINENO" 5
26428 fi
26851 fi
26852
26853 # Call helper function which possibly converts this using DOS-style short mode.
26854 # If so, the updated path is stored in $new_path.
26855 new_path="$input_to_shortpath"
26856
26857 input_path="$input_to_shortpath"
26858 # Check if we need to convert this using DOS-style short mode. If the path
26859 # contains just simple characters, use it. Otherwise (spaces, weird characters),
26860 # take no chances and rewrite it.
26861 # Note: m4 eats our [], so we need to use [ and ] instead.
26862 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
26863 if test "x$has_forbidden_chars" != x; then
26864 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
26865 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
26866 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
26867 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
26868 # Going to short mode and back again did indeed matter. Since short mode is
26869 # case insensitive, let's make it lowercase to improve readability.
26870 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
26871 # Now convert it back to Unix-style (cygpath)
26872 input_path=`$CYGPATH -u "$shortmode_path"`
26873 new_path="$input_path"
26874 fi
26875 fi
26876
26877 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
26878 if test "x$test_cygdrive_prefix" = x; then
26879 # As a simple fix, exclude /usr/bin since it's not a real path.
26880 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
26881 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
26882 # a path prefixed by /cygdrive for fixpath to work.
26883 new_path="$CYGWIN_ROOT_PATH$input_path"
26884 fi
26885 fi
26886
26887 # remove trailing .exe if any
26888 new_path="${new_path/%.exe/}"
26889
26890 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
26891
27308 fi
27309
27310 # Call helper function which possibly converts this using DOS-style short mode.
27311 # If so, the updated path is stored in $new_path.
27312 new_path="$input_to_shortpath"
27313
27314 input_path="$input_to_shortpath"
27315 # Check if we need to convert this using DOS-style short mode. If the path
27316 # contains just simple characters, use it. Otherwise (spaces, weird characters),
27317 # take no chances and rewrite it.
27318 # Note: m4 eats our [], so we need to use [ and ] instead.
27319 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
27320 if test "x$has_forbidden_chars" != x; then
27321 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
27322 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
27323 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
27324 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
27325 # Going to short mode and back again did indeed matter. Since short mode is
27326 # case insensitive, let's make it lowercase to improve readability.
27327 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
27328 # Now convert it back to Unix-style (cygpath)
27329 input_path=`$CYGPATH -u "$shortmode_path"`
27330 new_path="$input_path"
27331 fi
27332 fi
27333
27334 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
27335 if test "x$test_cygdrive_prefix" = x; then
27336 # As a simple fix, exclude /usr/bin since it's not a real path.
27337 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
27338 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
27339 # a path prefixed by /cygdrive for fixpath to work.
27340 new_path="$CYGWIN_ROOT_PATH$input_path"
27341 fi
27342 fi
27343
27344 # remove trailing .exe if any
27345 new_path="${new_path/%.exe/}"
27346
27347 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27348
28593 fi
28594
28595 # Call helper function which possibly converts this using DOS-style short mode.
28596 # If so, the updated path is stored in $new_path.
28597 new_path="$input_to_shortpath"
28598
28599 input_path="$input_to_shortpath"
28600 # Check if we need to convert this using DOS-style short mode. If the path
28601 # contains just simple characters, use it. Otherwise (spaces, weird characters),
28602 # take no chances and rewrite it.
28603 # Note: m4 eats our [], so we need to use [ and ] instead.
28604 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
28605 if test "x$has_forbidden_chars" != x; then
28606 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
28607 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
28608 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
28609 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
28610 # Going to short mode and back again did indeed matter. Since short mode is
28611 # case insensitive, let's make it lowercase to improve readability.
28612 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
28613 # Now convert it back to Unix-style (cygpath)
28614 input_path=`$CYGPATH -u "$shortmode_path"`
28615 new_path="$input_path"
28616 fi
28617 fi
28618
28619 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
28620 if test "x$test_cygdrive_prefix" = x; then
28621 # As a simple fix, exclude /usr/bin since it's not a real path.
28622 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
28623 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
28624 # a path prefixed by /cygdrive for fixpath to work.
28625 new_path="$CYGWIN_ROOT_PATH$input_path"
28626 fi
28627 fi
28628
28629 # remove trailing .exe if any
28630 new_path="${new_path/%.exe/}"
28631
28632 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28633
29050 fi
29051
29052 # Call helper function which possibly converts this using DOS-style short mode.
29053 # If so, the updated path is stored in $new_path.
29054 new_path="$input_to_shortpath"
29055
29056 input_path="$input_to_shortpath"
29057 # Check if we need to convert this using DOS-style short mode. If the path
29058 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29059 # take no chances and rewrite it.
29060 # Note: m4 eats our [], so we need to use [ and ] instead.
29061 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29062 if test "x$has_forbidden_chars" != x; then
29063 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29064 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29065 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29066 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29067 # Going to short mode and back again did indeed matter. Since short mode is
29068 # case insensitive, let's make it lowercase to improve readability.
29069 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29070 # Now convert it back to Unix-style (cygpath)
29071 input_path=`$CYGPATH -u "$shortmode_path"`
29072 new_path="$input_path"
29073 fi
29074 fi
29075
29076 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29077 if test "x$test_cygdrive_prefix" = x; then
29078 # As a simple fix, exclude /usr/bin since it's not a real path.
29079 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
29080 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29081 # a path prefixed by /cygdrive for fixpath to work.
29082 new_path="$CYGWIN_ROOT_PATH$input_path"
29083 fi
29084 fi
29085
29086 # remove trailing .exe if any
29087 new_path="${new_path/%.exe/}"
29088
29089 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29090
29940 fi
29941
29942 # Call helper function which possibly converts this using DOS-style short mode.
29943 # If so, the updated path is stored in $new_path.
29944 new_path="$input_to_shortpath"
29945
29946 input_path="$input_to_shortpath"
29947 # Check if we need to convert this using DOS-style short mode. If the path
29948 # contains just simple characters, use it. Otherwise (spaces, weird characters),
29949 # take no chances and rewrite it.
29950 # Note: m4 eats our [], so we need to use [ and ] instead.
29951 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
29952 if test "x$has_forbidden_chars" != x; then
29953 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
29954 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
29955 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
29956 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
29957 # Going to short mode and back again did indeed matter. Since short mode is
29958 # case insensitive, let's make it lowercase to improve readability.
29959 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
29960 # Now convert it back to Unix-style (cygpath)
29961 input_path=`$CYGPATH -u "$shortmode_path"`
29962 new_path="$input_path"
29963 fi
29964 fi
29965
29966 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
29967 if test "x$test_cygdrive_prefix" = x; then
29968 # As a simple fix, exclude /usr/bin since it's not a real path.
29969 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
29970 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
29971 # a path prefixed by /cygdrive for fixpath to work.
29972 new_path="$CYGWIN_ROOT_PATH$input_path"
29973 fi
29974 fi
29975
29976 # remove trailing .exe if any
29977 new_path="${new_path/%.exe/}"
29978
29979 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29980
30355 fi
30356
30357 # Call helper function which possibly converts this using DOS-style short mode.
30358 # If so, the updated path is stored in $new_path.
30359 new_path="$input_to_shortpath"
30360
30361 input_path="$input_to_shortpath"
30362 # Check if we need to convert this using DOS-style short mode. If the path
30363 # contains just simple characters, use it. Otherwise (spaces, weird characters),
30364 # take no chances and rewrite it.
30365 # Note: m4 eats our [], so we need to use [ and ] instead.
30366 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
30367 if test "x$has_forbidden_chars" != x; then
30368 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
30369 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
30370 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
30371 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
30372 # Going to short mode and back again did indeed matter. Since short mode is
30373 # case insensitive, let's make it lowercase to improve readability.
30374 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
30375 # Now convert it back to Unix-style (cygpath)
30376 input_path=`$CYGPATH -u "$shortmode_path"`
30377 new_path="$input_path"
30378 fi
30379 fi
30380
30381 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
30382 if test "x$test_cygdrive_prefix" = x; then
30383 # As a simple fix, exclude /usr/bin since it's not a real path.
30384 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
30385 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
30386 # a path prefixed by /cygdrive for fixpath to work.
30387 new_path="$CYGWIN_ROOT_PATH$input_path"
30388 fi
30389 fi
30390
30391 # remove trailing .exe if any
30392 new_path="${new_path/%.exe/}"
30393
30394 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30395
30699 fi
30700
30701 # Call helper function which possibly converts this using DOS-style short mode.
30702 # If so, the updated path is stored in $new_path.
30703 new_path="$input_to_shortpath"
30704
30705 input_path="$input_to_shortpath"
30706 # Check if we need to convert this using DOS-style short mode. If the path
30707 # contains just simple characters, use it. Otherwise (spaces, weird characters),
30708 # take no chances and rewrite it.
30709 # Note: m4 eats our [], so we need to use [ and ] instead.
30710 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
30711 if test "x$has_forbidden_chars" != x; then
30712 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
30713 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
30714 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
30715 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
30716 # Going to short mode and back again did indeed matter. Since short mode is
30717 # case insensitive, let's make it lowercase to improve readability.
30718 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
30719 # Now convert it back to Unix-style (cygpath)
30720 input_path=`$CYGPATH -u "$shortmode_path"`
30721 new_path="$input_path"
30722 fi
30723 fi
30724
30725 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
30726 if test "x$test_cygdrive_prefix" = x; then
30727 # As a simple fix, exclude /usr/bin since it's not a real path.
30728 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
30729 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
30730 # a path prefixed by /cygdrive for fixpath to work.
30731 new_path="$CYGWIN_ROOT_PATH$input_path"
30732 fi
30733 fi
30734
30735 # remove trailing .exe if any
30736 new_path="${new_path/%.exe/}"
30737
30738 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30739
31194 fi
31195
31196 # Call helper function which possibly converts this using DOS-style short mode.
31197 # If so, the updated path is stored in $new_path.
31198 new_path="$input_to_shortpath"
31199
31200 input_path="$input_to_shortpath"
31201 # Check if we need to convert this using DOS-style short mode. If the path
31202 # contains just simple characters, use it. Otherwise (spaces, weird characters),
31203 # take no chances and rewrite it.
31204 # Note: m4 eats our [], so we need to use [ and ] instead.
31205 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
31206 if test "x$has_forbidden_chars" != x; then
31207 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
31208 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
31209 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
31210 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
31211 # Going to short mode and back again did indeed matter. Since short mode is
31212 # case insensitive, let's make it lowercase to improve readability.
31213 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
31214 # Now convert it back to Unix-style (cygpath)
31215 input_path=`$CYGPATH -u "$shortmode_path"`
31216 new_path="$input_path"
31217 fi
31218 fi
31219
31220 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
31221 if test "x$test_cygdrive_prefix" = x; then
31222 # As a simple fix, exclude /usr/bin since it's not a real path.
31223 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
31224 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
31225 # a path prefixed by /cygdrive for fixpath to work.
31226 new_path="$CYGWIN_ROOT_PATH$input_path"
31227 fi
31228 fi
31229
31230 # remove trailing .exe if any
31231 new_path="${new_path/%.exe/}"
31232
31233 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31234
31822 fi
31823
31824 # Call helper function which possibly converts this using DOS-style short mode.
31825 # If so, the updated path is stored in $new_path.
31826 new_path="$input_to_shortpath"
31827
31828 input_path="$input_to_shortpath"
31829 # Check if we need to convert this using DOS-style short mode. If the path
31830 # contains just simple characters, use it. Otherwise (spaces, weird characters),
31831 # take no chances and rewrite it.
31832 # Note: m4 eats our [], so we need to use [ and ] instead.
31833 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
31834 if test "x$has_forbidden_chars" != x; then
31835 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
31836 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
31837 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
31838 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
31839 # Going to short mode and back again did indeed matter. Since short mode is
31840 # case insensitive, let's make it lowercase to improve readability.
31841 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
31842 # Now convert it back to Unix-style (cygpath)
31843 input_path=`$CYGPATH -u "$shortmode_path"`
31844 new_path="$input_path"
31845 fi
31846 fi
31847
31848 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
31849 if test "x$test_cygdrive_prefix" = x; then
31850 # As a simple fix, exclude /usr/bin since it's not a real path.
31851 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
31852 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
31853 # a path prefixed by /cygdrive for fixpath to work.
31854 new_path="$CYGWIN_ROOT_PATH$input_path"
31855 fi
31856 fi
31857
31858 # remove trailing .exe if any
31859 new_path="${new_path/%.exe/}"
31860
31861 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31862
32358 fi
32359
32360 # Call helper function which possibly converts this using DOS-style short mode.
32361 # If so, the updated path is stored in $new_path.
32362 new_path="$input_to_shortpath"
32363
32364 input_path="$input_to_shortpath"
32365 # Check if we need to convert this using DOS-style short mode. If the path
32366 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32367 # take no chances and rewrite it.
32368 # Note: m4 eats our [], so we need to use [ and ] instead.
32369 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32370 if test "x$has_forbidden_chars" != x; then
32371 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32372 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32373 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32374 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32375 # Going to short mode and back again did indeed matter. Since short mode is
32376 # case insensitive, let's make it lowercase to improve readability.
32377 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32378 # Now convert it back to Unix-style (cygpath)
32379 input_path=`$CYGPATH -u "$shortmode_path"`
32380 new_path="$input_path"
32381 fi
32382 fi
32383
32384 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32385 if test "x$test_cygdrive_prefix" = x; then
32386 # As a simple fix, exclude /usr/bin since it's not a real path.
32387 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
32388 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32389 # a path prefixed by /cygdrive for fixpath to work.
32390 new_path="$CYGWIN_ROOT_PATH$input_path"
32391 fi
32392 fi
32393
32394 # remove trailing .exe if any
32395 new_path="${new_path/%.exe/}"
32396
32397 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32398
32826 fi
32827
32828 # Call helper function which possibly converts this using DOS-style short mode.
32829 # If so, the updated path is stored in $new_path.
32830 new_path="$input_to_shortpath"
32831
32832 input_path="$input_to_shortpath"
32833 # Check if we need to convert this using DOS-style short mode. If the path
32834 # contains just simple characters, use it. Otherwise (spaces, weird characters),
32835 # take no chances and rewrite it.
32836 # Note: m4 eats our [], so we need to use [ and ] instead.
32837 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
32838 if test "x$has_forbidden_chars" != x; then
32839 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
32840 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
32841 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
32842 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
32843 # Going to short mode and back again did indeed matter. Since short mode is
32844 # case insensitive, let's make it lowercase to improve readability.
32845 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
32846 # Now convert it back to Unix-style (cygpath)
32847 input_path=`$CYGPATH -u "$shortmode_path"`
32848 new_path="$input_path"
32849 fi
32850 fi
32851
32852 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
32853 if test "x$test_cygdrive_prefix" = x; then
32854 # As a simple fix, exclude /usr/bin since it's not a real path.
32855 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
32856 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
32857 # a path prefixed by /cygdrive for fixpath to work.
32858 new_path="$CYGWIN_ROOT_PATH$input_path"
32859 fi
32860 fi
32861
32862 # remove trailing .exe if any
32863 new_path="${new_path/%.exe/}"
32864
32865 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32866
33167 fi
33168
33169 # Call helper function which possibly converts this using DOS-style short mode.
33170 # If so, the updated path is stored in $new_path.
33171 new_path="$input_to_shortpath"
33172
33173 input_path="$input_to_shortpath"
33174 # Check if we need to convert this using DOS-style short mode. If the path
33175 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33176 # take no chances and rewrite it.
33177 # Note: m4 eats our [], so we need to use [ and ] instead.
33178 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33179 if test "x$has_forbidden_chars" != x; then
33180 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33181 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33182 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33183 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33184 # Going to short mode and back again did indeed matter. Since short mode is
33185 # case insensitive, let's make it lowercase to improve readability.
33186 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33187 # Now convert it back to Unix-style (cygpath)
33188 input_path=`$CYGPATH -u "$shortmode_path"`
33189 new_path="$input_path"
33190 fi
33191 fi
33192
33193 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33194 if test "x$test_cygdrive_prefix" = x; then
33195 # As a simple fix, exclude /usr/bin since it's not a real path.
33196 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33197 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33198 # a path prefixed by /cygdrive for fixpath to work.
33199 new_path="$CYGWIN_ROOT_PATH$input_path"
33200 fi
33201 fi
33202
33203 # remove trailing .exe if any
33204 new_path="${new_path/%.exe/}"
33205
33206 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33207
33504 fi
33505
33506 # Call helper function which possibly converts this using DOS-style short mode.
33507 # If so, the updated path is stored in $new_path.
33508 new_path="$input_to_shortpath"
33509
33510 input_path="$input_to_shortpath"
33511 # Check if we need to convert this using DOS-style short mode. If the path
33512 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33513 # take no chances and rewrite it.
33514 # Note: m4 eats our [], so we need to use [ and ] instead.
33515 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33516 if test "x$has_forbidden_chars" != x; then
33517 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33518 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33519 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33520 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33521 # Going to short mode and back again did indeed matter. Since short mode is
33522 # case insensitive, let's make it lowercase to improve readability.
33523 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33524 # Now convert it back to Unix-style (cygpath)
33525 input_path=`$CYGPATH -u "$shortmode_path"`
33526 new_path="$input_path"
33527 fi
33528 fi
33529
33530 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33531 if test "x$test_cygdrive_prefix" = x; then
33532 # As a simple fix, exclude /usr/bin since it's not a real path.
33533 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33534 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33535 # a path prefixed by /cygdrive for fixpath to work.
33536 new_path="$CYGWIN_ROOT_PATH$input_path"
33537 fi
33538 fi
33539
33540 # remove trailing .exe if any
33541 new_path="${new_path/%.exe/}"
33542
33543 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33544
33823 fi
33824
33825 # Call helper function which possibly converts this using DOS-style short mode.
33826 # If so, the updated path is stored in $new_path.
33827 new_path="$input_to_shortpath"
33828
33829 input_path="$input_to_shortpath"
33830 # Check if we need to convert this using DOS-style short mode. If the path
33831 # contains just simple characters, use it. Otherwise (spaces, weird characters),
33832 # take no chances and rewrite it.
33833 # Note: m4 eats our [], so we need to use [ and ] instead.
33834 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
33835 if test "x$has_forbidden_chars" != x; then
33836 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
33837 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
33838 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
33839 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
33840 # Going to short mode and back again did indeed matter. Since short mode is
33841 # case insensitive, let's make it lowercase to improve readability.
33842 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
33843 # Now convert it back to Unix-style (cygpath)
33844 input_path=`$CYGPATH -u "$shortmode_path"`
33845 new_path="$input_path"
33846 fi
33847 fi
33848
33849 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
33850 if test "x$test_cygdrive_prefix" = x; then
33851 # As a simple fix, exclude /usr/bin since it's not a real path.
33852 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
33853 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
33854 # a path prefixed by /cygdrive for fixpath to work.
33855 new_path="$CYGWIN_ROOT_PATH$input_path"
33856 fi
33857 fi
33858
33859 # remove trailing .exe if any
33860 new_path="${new_path/%.exe/}"
33861
33862 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33863
34338 fi
34339
34340 # Call helper function which possibly converts this using DOS-style short mode.
34341 # If so, the updated path is stored in $new_path.
34342 new_path="$input_to_shortpath"
34343
34344 input_path="$input_to_shortpath"
34345 # Check if we need to convert this using DOS-style short mode. If the path
34346 # contains just simple characters, use it. Otherwise (spaces, weird characters),
34347 # take no chances and rewrite it.
34348 # Note: m4 eats our [], so we need to use [ and ] instead.
34349 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
34350 if test "x$has_forbidden_chars" != x; then
34351 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
34352 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
34353 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
34354 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
34355 # Going to short mode and back again did indeed matter. Since short mode is
34356 # case insensitive, let's make it lowercase to improve readability.
34357 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
34358 # Now convert it back to Unix-style (cygpath)
34359 input_path=`$CYGPATH -u "$shortmode_path"`
34360 new_path="$input_path"
34361 fi
34362 fi
34363
34364 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
34365 if test "x$test_cygdrive_prefix" = x; then
34366 # As a simple fix, exclude /usr/bin since it's not a real path.
34367 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
34368 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
34369 # a path prefixed by /cygdrive for fixpath to work.
34370 new_path="$CYGWIN_ROOT_PATH$input_path"
34371 fi
34372 fi
34373
34374 # remove trailing .exe if any
34375 new_path="${new_path/%.exe/}"
34376
34377 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34378
34806 fi
34807
34808 # Call helper function which possibly converts this using DOS-style short mode.
34809 # If so, the updated path is stored in $new_path.
34810 new_path="$input_to_shortpath"
34811
34812 input_path="$input_to_shortpath"
34813 # Check if we need to convert this using DOS-style short mode. If the path
34814 # contains just simple characters, use it. Otherwise (spaces, weird characters),
34815 # take no chances and rewrite it.
34816 # Note: m4 eats our [], so we need to use [ and ] instead.
34817 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
34818 if test "x$has_forbidden_chars" != x; then
34819 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
34820 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
34821 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
34822 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
34823 # Going to short mode and back again did indeed matter. Since short mode is
34824 # case insensitive, let's make it lowercase to improve readability.
34825 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
34826 # Now convert it back to Unix-style (cygpath)
34827 input_path=`$CYGPATH -u "$shortmode_path"`
34828 new_path="$input_path"
34829 fi
34830 fi
34831
34832 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
34833 if test "x$test_cygdrive_prefix" = x; then
34834 # As a simple fix, exclude /usr/bin since it's not a real path.
34835 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
34836 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
34837 # a path prefixed by /cygdrive for fixpath to work.
34838 new_path="$CYGWIN_ROOT_PATH$input_path"
34839 fi
34840 fi
34841
34842 # remove trailing .exe if any
34843 new_path="${new_path/%.exe/}"
34844
34845 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34846
35274 fi
35275
35276 # Call helper function which possibly converts this using DOS-style short mode.
35277 # If so, the updated path is stored in $new_path.
35278 new_path="$input_to_shortpath"
35279
35280 input_path="$input_to_shortpath"
35281 # Check if we need to convert this using DOS-style short mode. If the path
35282 # contains just simple characters, use it. Otherwise (spaces, weird characters),
35283 # take no chances and rewrite it.
35284 # Note: m4 eats our [], so we need to use [ and ] instead.
35285 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
35286 if test "x$has_forbidden_chars" != x; then
35287 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
35288 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
35289 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
35290 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
35291 # Going to short mode and back again did indeed matter. Since short mode is
35292 # case insensitive, let's make it lowercase to improve readability.
35293 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
35294 # Now convert it back to Unix-style (cygpath)
35295 input_path=`$CYGPATH -u "$shortmode_path"`
35296 new_path="$input_path"
35297 fi
35298 fi
35299
35300 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
35301 if test "x$test_cygdrive_prefix" = x; then
35302 # As a simple fix, exclude /usr/bin since it's not a real path.
35303 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
35304 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
35305 # a path prefixed by /cygdrive for fixpath to work.
35306 new_path="$CYGWIN_ROOT_PATH$input_path"
35307 fi
35308 fi
35309
35310 # remove trailing .exe if any
35311 new_path="${new_path/%.exe/}"
35312
35313 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35314
35743 fi
35744
35745 # Call helper function which possibly converts this using DOS-style short mode.
35746 # If so, the updated path is stored in $new_path.
35747 new_path="$input_to_shortpath"
35748
35749 input_path="$input_to_shortpath"
35750 # Check if we need to convert this using DOS-style short mode. If the path
35751 # contains just simple characters, use it. Otherwise (spaces, weird characters),
35752 # take no chances and rewrite it.
35753 # Note: m4 eats our [], so we need to use [ and ] instead.
35754 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
35755 if test "x$has_forbidden_chars" != x; then
35756 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
35757 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
35758 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
35759 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
35760 # Going to short mode and back again did indeed matter. Since short mode is
35761 # case insensitive, let's make it lowercase to improve readability.
35762 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
35763 # Now convert it back to Unix-style (cygpath)
35764 input_path=`$CYGPATH -u "$shortmode_path"`
35765 new_path="$input_path"
35766 fi
35767 fi
35768
35769 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
35770 if test "x$test_cygdrive_prefix" = x; then
35771 # As a simple fix, exclude /usr/bin since it's not a real path.
35772 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
35773 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
35774 # a path prefixed by /cygdrive for fixpath to work.
35775 new_path="$CYGWIN_ROOT_PATH$input_path"
35776 fi
35777 fi
35778
35779 # remove trailing .exe if any
35780 new_path="${new_path/%.exe/}"
35781
35782 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35783
36323 fi
36324
36325 # Call helper function which possibly converts this using DOS-style short mode.
36326 # If so, the updated path is stored in $new_path.
36327 new_path="$input_to_shortpath"
36328
36329 input_path="$input_to_shortpath"
36330 # Check if we need to convert this using DOS-style short mode. If the path
36331 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36332 # take no chances and rewrite it.
36333 # Note: m4 eats our [], so we need to use [ and ] instead.
36334 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36335 if test "x$has_forbidden_chars" != x; then
36336 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36337 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36338 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36339 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36340 # Going to short mode and back again did indeed matter. Since short mode is
36341 # case insensitive, let's make it lowercase to improve readability.
36342 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36343 # Now convert it back to Unix-style (cygpath)
36344 input_path=`$CYGPATH -u "$shortmode_path"`
36345 new_path="$input_path"
36346 fi
36347 fi
36348
36349 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36350 if test "x$test_cygdrive_prefix" = x; then
36351 # As a simple fix, exclude /usr/bin since it's not a real path.
36352 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36353 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36354 # a path prefixed by /cygdrive for fixpath to work.
36355 new_path="$CYGWIN_ROOT_PATH$input_path"
36356 fi
36357 fi
36358
36359 # remove trailing .exe if any
36360 new_path="${new_path/%.exe/}"
36361
36362 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36363
36944 fi
36945
36946 # Call helper function which possibly converts this using DOS-style short mode.
36947 # If so, the updated path is stored in $new_path.
36948 new_path="$input_to_shortpath"
36949
36950 input_path="$input_to_shortpath"
36951 # Check if we need to convert this using DOS-style short mode. If the path
36952 # contains just simple characters, use it. Otherwise (spaces, weird characters),
36953 # take no chances and rewrite it.
36954 # Note: m4 eats our [], so we need to use [ and ] instead.
36955 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
36956 if test "x$has_forbidden_chars" != x; then
36957 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
36958 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
36959 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
36960 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
36961 # Going to short mode and back again did indeed matter. Since short mode is
36962 # case insensitive, let's make it lowercase to improve readability.
36963 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
36964 # Now convert it back to Unix-style (cygpath)
36965 input_path=`$CYGPATH -u "$shortmode_path"`
36966 new_path="$input_path"
36967 fi
36968 fi
36969
36970 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
36971 if test "x$test_cygdrive_prefix" = x; then
36972 # As a simple fix, exclude /usr/bin since it's not a real path.
36973 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
36974 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
36975 # a path prefixed by /cygdrive for fixpath to work.
36976 new_path="$CYGWIN_ROOT_PATH$input_path"
36977 fi
36978 fi
36979
36980 # remove trailing .exe if any
36981 new_path="${new_path/%.exe/}"
36982
36983 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36984
37531 fi
37532
37533 # Call helper function which possibly converts this using DOS-style short mode.
37534 # If so, the updated path is stored in $new_path.
37535 new_path="$input_to_shortpath"
37536
37537 input_path="$input_to_shortpath"
37538 # Check if we need to convert this using DOS-style short mode. If the path
37539 # contains just simple characters, use it. Otherwise (spaces, weird characters),
37540 # take no chances and rewrite it.
37541 # Note: m4 eats our [], so we need to use [ and ] instead.
37542 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
37543 if test "x$has_forbidden_chars" != x; then
37544 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
37545 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
37546 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
37547 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
37548 # Going to short mode and back again did indeed matter. Since short mode is
37549 # case insensitive, let's make it lowercase to improve readability.
37550 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
37551 # Now convert it back to Unix-style (cygpath)
37552 input_path=`$CYGPATH -u "$shortmode_path"`
37553 new_path="$input_path"
37554 fi
37555 fi
37556
37557 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
37558 if test "x$test_cygdrive_prefix" = x; then
37559 # As a simple fix, exclude /usr/bin since it's not a real path.
37560 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
37561 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
37562 # a path prefixed by /cygdrive for fixpath to work.
37563 new_path="$CYGWIN_ROOT_PATH$input_path"
37564 fi
37565 fi
37566
37567 # remove trailing .exe if any
37568 new_path="${new_path/%.exe/}"
37569
37570 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37571
38115 fi
38116
38117 # Call helper function which possibly converts this using DOS-style short mode.
38118 # If so, the updated path is stored in $new_path.
38119 new_path="$input_to_shortpath"
38120
38121 input_path="$input_to_shortpath"
38122 # Check if we need to convert this using DOS-style short mode. If the path
38123 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38124 # take no chances and rewrite it.
38125 # Note: m4 eats our [], so we need to use [ and ] instead.
38126 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38127 if test "x$has_forbidden_chars" != x; then
38128 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38129 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38130 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38131 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38132 # Going to short mode and back again did indeed matter. Since short mode is
38133 # case insensitive, let's make it lowercase to improve readability.
38134 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38135 # Now convert it back to Unix-style (cygpath)
38136 input_path=`$CYGPATH -u "$shortmode_path"`
38137 new_path="$input_path"
38138 fi
38139 fi
38140
38141 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38142 if test "x$test_cygdrive_prefix" = x; then
38143 # As a simple fix, exclude /usr/bin since it's not a real path.
38144 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38145 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38146 # a path prefixed by /cygdrive for fixpath to work.
38147 new_path="$CYGWIN_ROOT_PATH$input_path"
38148 fi
38149 fi
38150
38151 # remove trailing .exe if any
38152 new_path="${new_path/%.exe/}"
38153
38154 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38155
38608 fi
38609
38610 # Call helper function which possibly converts this using DOS-style short mode.
38611 # If so, the updated path is stored in $new_path.
38612 new_path="$input_to_shortpath"
38613
38614 input_path="$input_to_shortpath"
38615 # Check if we need to convert this using DOS-style short mode. If the path
38616 # contains just simple characters, use it. Otherwise (spaces, weird characters),
38617 # take no chances and rewrite it.
38618 # Note: m4 eats our [], so we need to use [ and ] instead.
38619 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
38620 if test "x$has_forbidden_chars" != x; then
38621 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
38622 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
38623 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
38624 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
38625 # Going to short mode and back again did indeed matter. Since short mode is
38626 # case insensitive, let's make it lowercase to improve readability.
38627 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
38628 # Now convert it back to Unix-style (cygpath)
38629 input_path=`$CYGPATH -u "$shortmode_path"`
38630 new_path="$input_path"
38631 fi
38632 fi
38633
38634 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
38635 if test "x$test_cygdrive_prefix" = x; then
38636 # As a simple fix, exclude /usr/bin since it's not a real path.
38637 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
38638 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
38639 # a path prefixed by /cygdrive for fixpath to work.
38640 new_path="$CYGWIN_ROOT_PATH$input_path"
38641 fi
38642 fi
38643
38644 # remove trailing .exe if any
38645 new_path="${new_path/%.exe/}"
38646
38647 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38648
39076 fi
39077
39078 # Call helper function which possibly converts this using DOS-style short mode.
39079 # If so, the updated path is stored in $new_path.
39080 new_path="$input_to_shortpath"
39081
39082 input_path="$input_to_shortpath"
39083 # Check if we need to convert this using DOS-style short mode. If the path
39084 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39085 # take no chances and rewrite it.
39086 # Note: m4 eats our [], so we need to use [ and ] instead.
39087 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39088 if test "x$has_forbidden_chars" != x; then
39089 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39090 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39091 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39092 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39093 # Going to short mode and back again did indeed matter. Since short mode is
39094 # case insensitive, let's make it lowercase to improve readability.
39095 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39096 # Now convert it back to Unix-style (cygpath)
39097 input_path=`$CYGPATH -u "$shortmode_path"`
39098 new_path="$input_path"
39099 fi
39100 fi
39101
39102 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39103 if test "x$test_cygdrive_prefix" = x; then
39104 # As a simple fix, exclude /usr/bin since it's not a real path.
39105 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
39106 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39107 # a path prefixed by /cygdrive for fixpath to work.
39108 new_path="$CYGWIN_ROOT_PATH$input_path"
39109 fi
39110 fi
39111
39112 # remove trailing .exe if any
39113 new_path="${new_path/%.exe/}"
39114
39115 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39116
39544 fi
39545
39546 # Call helper function which possibly converts this using DOS-style short mode.
39547 # If so, the updated path is stored in $new_path.
39548 new_path="$input_to_shortpath"
39549
39550 input_path="$input_to_shortpath"
39551 # Check if we need to convert this using DOS-style short mode. If the path
39552 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39553 # take no chances and rewrite it.
39554 # Note: m4 eats our [], so we need to use [ and ] instead.
39555 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39556 if test "x$has_forbidden_chars" != x; then
39557 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39558 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39559 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39560 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39561 # Going to short mode and back again did indeed matter. Since short mode is
39562 # case insensitive, let's make it lowercase to improve readability.
39563 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39564 # Now convert it back to Unix-style (cygpath)
39565 input_path=`$CYGPATH -u "$shortmode_path"`
39566 new_path="$input_path"
39567 fi
39568 fi
39569
39570 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39571 if test "x$test_cygdrive_prefix" = x; then
39572 # As a simple fix, exclude /usr/bin since it's not a real path.
39573 if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
39574 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39575 # a path prefixed by /cygdrive for fixpath to work.
39576 new_path="$CYGWIN_ROOT_PATH$input_path"
39577 fi
39578 fi
39579
39580 # remove trailing .exe if any
39581 new_path="${new_path/%.exe/}"
39582
39583 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39584
39924 as_fn_error $? "Cannot locate the the path of JT_HOME" "$LINENO" 5
39925 fi
39926
39927 # Call helper function which possibly converts this using DOS-style short mode.
39928 # If so, the updated path is stored in $new_path.
39929
39930 input_path="$new_path"
39931 # Check if we need to convert this using DOS-style short mode. If the path
39932 # contains just simple characters, use it. Otherwise (spaces, weird characters),
39933 # take no chances and rewrite it.
39934 # Note: m4 eats our [], so we need to use [ and ] instead.
39935 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
39936 if test "x$has_forbidden_chars" != x; then
39937 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
39938 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
39939 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
39940 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
39941 # Going to short mode and back again did indeed matter. Since short mode is
39942 # case insensitive, let's make it lowercase to improve readability.
39943 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
39944 # Now convert it back to Unix-style (cygpath)
39945 input_path=`$CYGPATH -u "$shortmode_path"`
39946 new_path="$input_path"
39947 fi
39948 fi
39949
39950 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
39951 if test "x$test_cygdrive_prefix" = x; then
39952 # As a simple fix, exclude /usr/bin since it's not a real path.
39953 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
39954 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
39955 # a path prefixed by /cygdrive for fixpath to work.
39956 new_path="$CYGWIN_ROOT_PATH$input_path"
39957 fi
39958 fi
39959
39960
39961 if test "x$path" != "x$new_path"; then
39962 JT_HOME="$new_path"
39963 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
39964 $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
43461 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
43462 fi
43463
43464 # Call helper function which possibly converts this using DOS-style short mode.
43465 # If so, the updated path is stored in $new_path.
43466
43467 input_path="$new_path"
43468 # Check if we need to convert this using DOS-style short mode. If the path
43469 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43470 # take no chances and rewrite it.
43471 # Note: m4 eats our [], so we need to use [ and ] instead.
43472 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43473 if test "x$has_forbidden_chars" != x; then
43474 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43475 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43476 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43477 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43478 # Going to short mode and back again did indeed matter. Since short mode is
43479 # case insensitive, let's make it lowercase to improve readability.
43480 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43481 # Now convert it back to Unix-style (cygpath)
43482 input_path=`$CYGPATH -u "$shortmode_path"`
43483 new_path="$input_path"
43484 fi
43485 fi
43486
43487 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43488 if test "x$test_cygdrive_prefix" = x; then
43489 # As a simple fix, exclude /usr/bin since it's not a real path.
43490 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43491 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43492 # a path prefixed by /cygdrive for fixpath to work.
43493 new_path="$CYGWIN_ROOT_PATH$input_path"
43494 fi
43495 fi
43496
43497
43498 if test "x$path" != "x$new_path"; then
43499 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
43500 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
43501 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
43583 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
43584 fi
43585
43586 # Call helper function which possibly converts this using DOS-style short mode.
43587 # If so, the updated path is stored in $new_path.
43588
43589 input_path="$new_path"
43590 # Check if we need to convert this using DOS-style short mode. If the path
43591 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43592 # take no chances and rewrite it.
43593 # Note: m4 eats our [], so we need to use [ and ] instead.
43594 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43595 if test "x$has_forbidden_chars" != x; then
43596 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43597 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43598 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43599 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43600 # Going to short mode and back again did indeed matter. Since short mode is
43601 # case insensitive, let's make it lowercase to improve readability.
43602 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43603 # Now convert it back to Unix-style (cygpath)
43604 input_path=`$CYGPATH -u "$shortmode_path"`
43605 new_path="$input_path"
43606 fi
43607 fi
43608
43609 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43610 if test "x$test_cygdrive_prefix" = x; then
43611 # As a simple fix, exclude /usr/bin since it's not a real path.
43612 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43613 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43614 # a path prefixed by /cygdrive for fixpath to work.
43615 new_path="$CYGWIN_ROOT_PATH$input_path"
43616 fi
43617 fi
43618
43619
43620 if test "x$path" != "x$new_path"; then
43621 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
43622 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
43623 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
43788 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
43789 fi
43790
43791 # Call helper function which possibly converts this using DOS-style short mode.
43792 # If so, the updated path is stored in $new_path.
43793
43794 input_path="$new_path"
43795 # Check if we need to convert this using DOS-style short mode. If the path
43796 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43797 # take no chances and rewrite it.
43798 # Note: m4 eats our [], so we need to use [ and ] instead.
43799 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43800 if test "x$has_forbidden_chars" != x; then
43801 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43802 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43803 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43804 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43805 # Going to short mode and back again did indeed matter. Since short mode is
43806 # case insensitive, let's make it lowercase to improve readability.
43807 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43808 # Now convert it back to Unix-style (cygpath)
43809 input_path=`$CYGPATH -u "$shortmode_path"`
43810 new_path="$input_path"
43811 fi
43812 fi
43813
43814 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43815 if test "x$test_cygdrive_prefix" = x; then
43816 # As a simple fix, exclude /usr/bin since it's not a real path.
43817 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43818 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43819 # a path prefixed by /cygdrive for fixpath to work.
43820 new_path="$CYGWIN_ROOT_PATH$input_path"
43821 fi
43822 fi
43823
43824
43825 if test "x$path" != "x$new_path"; then
43826 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
43827 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
43828 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
43910 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
43911 fi
43912
43913 # Call helper function which possibly converts this using DOS-style short mode.
43914 # If so, the updated path is stored in $new_path.
43915
43916 input_path="$new_path"
43917 # Check if we need to convert this using DOS-style short mode. If the path
43918 # contains just simple characters, use it. Otherwise (spaces, weird characters),
43919 # take no chances and rewrite it.
43920 # Note: m4 eats our [], so we need to use [ and ] instead.
43921 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
43922 if test "x$has_forbidden_chars" != x; then
43923 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
43924 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
43925 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
43926 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
43927 # Going to short mode and back again did indeed matter. Since short mode is
43928 # case insensitive, let's make it lowercase to improve readability.
43929 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
43930 # Now convert it back to Unix-style (cygpath)
43931 input_path=`$CYGPATH -u "$shortmode_path"`
43932 new_path="$input_path"
43933 fi
43934 fi
43935
43936 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
43937 if test "x$test_cygdrive_prefix" = x; then
43938 # As a simple fix, exclude /usr/bin since it's not a real path.
43939 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
43940 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
43941 # a path prefixed by /cygdrive for fixpath to work.
43942 new_path="$CYGWIN_ROOT_PATH$input_path"
43943 fi
43944 fi
43945
43946
43947 if test "x$path" != "x$new_path"; then
43948 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
43949 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
43950 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44376 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
44377 fi
44378
44379 # Call helper function which possibly converts this using DOS-style short mode.
44380 # If so, the updated path is stored in $new_path.
44381
44382 input_path="$new_path"
44383 # Check if we need to convert this using DOS-style short mode. If the path
44384 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44385 # take no chances and rewrite it.
44386 # Note: m4 eats our [], so we need to use [ and ] instead.
44387 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44388 if test "x$has_forbidden_chars" != x; then
44389 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44390 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44391 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44392 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44393 # Going to short mode and back again did indeed matter. Since short mode is
44394 # case insensitive, let's make it lowercase to improve readability.
44395 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44396 # Now convert it back to Unix-style (cygpath)
44397 input_path=`$CYGPATH -u "$shortmode_path"`
44398 new_path="$input_path"
44399 fi
44400 fi
44401
44402 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44403 if test "x$test_cygdrive_prefix" = x; then
44404 # As a simple fix, exclude /usr/bin since it's not a real path.
44405 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44406 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44407 # a path prefixed by /cygdrive for fixpath to work.
44408 new_path="$CYGWIN_ROOT_PATH$input_path"
44409 fi
44410 fi
44411
44412
44413 if test "x$path" != "x$new_path"; then
44414 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44415 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44416 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44498 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
44499 fi
44500
44501 # Call helper function which possibly converts this using DOS-style short mode.
44502 # If so, the updated path is stored in $new_path.
44503
44504 input_path="$new_path"
44505 # Check if we need to convert this using DOS-style short mode. If the path
44506 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44507 # take no chances and rewrite it.
44508 # Note: m4 eats our [], so we need to use [ and ] instead.
44509 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44510 if test "x$has_forbidden_chars" != x; then
44511 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44512 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44513 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44514 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44515 # Going to short mode and back again did indeed matter. Since short mode is
44516 # case insensitive, let's make it lowercase to improve readability.
44517 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44518 # Now convert it back to Unix-style (cygpath)
44519 input_path=`$CYGPATH -u "$shortmode_path"`
44520 new_path="$input_path"
44521 fi
44522 fi
44523
44524 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44525 if test "x$test_cygdrive_prefix" = x; then
44526 # As a simple fix, exclude /usr/bin since it's not a real path.
44527 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44528 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44529 # a path prefixed by /cygdrive for fixpath to work.
44530 new_path="$CYGWIN_ROOT_PATH$input_path"
44531 fi
44532 fi
44533
44534
44535 if test "x$path" != "x$new_path"; then
44536 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
44537 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
44538 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44678 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
44679 fi
44680
44681 # Call helper function which possibly converts this using DOS-style short mode.
44682 # If so, the updated path is stored in $new_path.
44683
44684 input_path="$new_path"
44685 # Check if we need to convert this using DOS-style short mode. If the path
44686 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44687 # take no chances and rewrite it.
44688 # Note: m4 eats our [], so we need to use [ and ] instead.
44689 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44690 if test "x$has_forbidden_chars" != x; then
44691 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44692 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44693 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44694 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44695 # Going to short mode and back again did indeed matter. Since short mode is
44696 # case insensitive, let's make it lowercase to improve readability.
44697 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44698 # Now convert it back to Unix-style (cygpath)
44699 input_path=`$CYGPATH -u "$shortmode_path"`
44700 new_path="$input_path"
44701 fi
44702 fi
44703
44704 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44705 if test "x$test_cygdrive_prefix" = x; then
44706 # As a simple fix, exclude /usr/bin since it's not a real path.
44707 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44708 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44709 # a path prefixed by /cygdrive for fixpath to work.
44710 new_path="$CYGWIN_ROOT_PATH$input_path"
44711 fi
44712 fi
44713
44714
44715 if test "x$path" != "x$new_path"; then
44716 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44717 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44718 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44800 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
44801 fi
44802
44803 # Call helper function which possibly converts this using DOS-style short mode.
44804 # If so, the updated path is stored in $new_path.
44805
44806 input_path="$new_path"
44807 # Check if we need to convert this using DOS-style short mode. If the path
44808 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44809 # take no chances and rewrite it.
44810 # Note: m4 eats our [], so we need to use [ and ] instead.
44811 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44812 if test "x$has_forbidden_chars" != x; then
44813 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44814 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44815 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44816 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44817 # Going to short mode and back again did indeed matter. Since short mode is
44818 # case insensitive, let's make it lowercase to improve readability.
44819 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44820 # Now convert it back to Unix-style (cygpath)
44821 input_path=`$CYGPATH -u "$shortmode_path"`
44822 new_path="$input_path"
44823 fi
44824 fi
44825
44826 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44827 if test "x$test_cygdrive_prefix" = x; then
44828 # As a simple fix, exclude /usr/bin since it's not a real path.
44829 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
44830 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
44831 # a path prefixed by /cygdrive for fixpath to work.
44832 new_path="$CYGWIN_ROOT_PATH$input_path"
44833 fi
44834 fi
44835
44836
44837 if test "x$path" != "x$new_path"; then
44838 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
44839 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
44840 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44971 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
44972 fi
44973
44974 # Call helper function which possibly converts this using DOS-style short mode.
44975 # If so, the updated path is stored in $new_path.
44976
44977 input_path="$new_path"
44978 # Check if we need to convert this using DOS-style short mode. If the path
44979 # contains just simple characters, use it. Otherwise (spaces, weird characters),
44980 # take no chances and rewrite it.
44981 # Note: m4 eats our [], so we need to use [ and ] instead.
44982 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
44983 if test "x$has_forbidden_chars" != x; then
44984 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
44985 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
44986 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
44987 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
44988 # Going to short mode and back again did indeed matter. Since short mode is
44989 # case insensitive, let's make it lowercase to improve readability.
44990 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
44991 # Now convert it back to Unix-style (cygpath)
44992 input_path=`$CYGPATH -u "$shortmode_path"`
44993 new_path="$input_path"
44994 fi
44995 fi
44996
44997 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
44998 if test "x$test_cygdrive_prefix" = x; then
44999 # As a simple fix, exclude /usr/bin since it's not a real path.
45000 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45001 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45002 # a path prefixed by /cygdrive for fixpath to work.
45003 new_path="$CYGWIN_ROOT_PATH$input_path"
45004 fi
45005 fi
45006
45007
45008 if test "x$path" != "x$new_path"; then
45009 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45010 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45011 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45093 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45094 fi
45095
45096 # Call helper function which possibly converts this using DOS-style short mode.
45097 # If so, the updated path is stored in $new_path.
45098
45099 input_path="$new_path"
45100 # Check if we need to convert this using DOS-style short mode. If the path
45101 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45102 # take no chances and rewrite it.
45103 # Note: m4 eats our [], so we need to use [ and ] instead.
45104 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45105 if test "x$has_forbidden_chars" != x; then
45106 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45107 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45108 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45109 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45110 # Going to short mode and back again did indeed matter. Since short mode is
45111 # case insensitive, let's make it lowercase to improve readability.
45112 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45113 # Now convert it back to Unix-style (cygpath)
45114 input_path=`$CYGPATH -u "$shortmode_path"`
45115 new_path="$input_path"
45116 fi
45117 fi
45118
45119 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45120 if test "x$test_cygdrive_prefix" = x; then
45121 # As a simple fix, exclude /usr/bin since it's not a real path.
45122 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45123 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45124 # a path prefixed by /cygdrive for fixpath to work.
45125 new_path="$CYGWIN_ROOT_PATH$input_path"
45126 fi
45127 fi
45128
45129
45130 if test "x$path" != "x$new_path"; then
45131 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45132 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45133 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45264 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
45265 fi
45266
45267 # Call helper function which possibly converts this using DOS-style short mode.
45268 # If so, the updated path is stored in $new_path.
45269
45270 input_path="$new_path"
45271 # Check if we need to convert this using DOS-style short mode. If the path
45272 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45273 # take no chances and rewrite it.
45274 # Note: m4 eats our [], so we need to use [ and ] instead.
45275 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45276 if test "x$has_forbidden_chars" != x; then
45277 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45278 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45279 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45280 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45281 # Going to short mode and back again did indeed matter. Since short mode is
45282 # case insensitive, let's make it lowercase to improve readability.
45283 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45284 # Now convert it back to Unix-style (cygpath)
45285 input_path=`$CYGPATH -u "$shortmode_path"`
45286 new_path="$input_path"
45287 fi
45288 fi
45289
45290 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45291 if test "x$test_cygdrive_prefix" = x; then
45292 # As a simple fix, exclude /usr/bin since it's not a real path.
45293 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45294 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45295 # a path prefixed by /cygdrive for fixpath to work.
45296 new_path="$CYGWIN_ROOT_PATH$input_path"
45297 fi
45298 fi
45299
45300
45301 if test "x$path" != "x$new_path"; then
45302 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45303 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45304 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45386 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45387 fi
45388
45389 # Call helper function which possibly converts this using DOS-style short mode.
45390 # If so, the updated path is stored in $new_path.
45391
45392 input_path="$new_path"
45393 # Check if we need to convert this using DOS-style short mode. If the path
45394 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45395 # take no chances and rewrite it.
45396 # Note: m4 eats our [], so we need to use [ and ] instead.
45397 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45398 if test "x$has_forbidden_chars" != x; then
45399 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45400 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45401 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45402 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45403 # Going to short mode and back again did indeed matter. Since short mode is
45404 # case insensitive, let's make it lowercase to improve readability.
45405 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45406 # Now convert it back to Unix-style (cygpath)
45407 input_path=`$CYGPATH -u "$shortmode_path"`
45408 new_path="$input_path"
45409 fi
45410 fi
45411
45412 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45413 if test "x$test_cygdrive_prefix" = x; then
45414 # As a simple fix, exclude /usr/bin since it's not a real path.
45415 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45416 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45417 # a path prefixed by /cygdrive for fixpath to work.
45418 new_path="$CYGWIN_ROOT_PATH$input_path"
45419 fi
45420 fi
45421
45422
45423 if test "x$path" != "x$new_path"; then
45424 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45425 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45426 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45558 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
45559 fi
45560
45561 # Call helper function which possibly converts this using DOS-style short mode.
45562 # If so, the updated path is stored in $new_path.
45563
45564 input_path="$new_path"
45565 # Check if we need to convert this using DOS-style short mode. If the path
45566 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45567 # take no chances and rewrite it.
45568 # Note: m4 eats our [], so we need to use [ and ] instead.
45569 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45570 if test "x$has_forbidden_chars" != x; then
45571 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45572 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45573 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45574 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45575 # Going to short mode and back again did indeed matter. Since short mode is
45576 # case insensitive, let's make it lowercase to improve readability.
45577 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45578 # Now convert it back to Unix-style (cygpath)
45579 input_path=`$CYGPATH -u "$shortmode_path"`
45580 new_path="$input_path"
45581 fi
45582 fi
45583
45584 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45585 if test "x$test_cygdrive_prefix" = x; then
45586 # As a simple fix, exclude /usr/bin since it's not a real path.
45587 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45588 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45589 # a path prefixed by /cygdrive for fixpath to work.
45590 new_path="$CYGWIN_ROOT_PATH$input_path"
45591 fi
45592 fi
45593
45594
45595 if test "x$path" != "x$new_path"; then
45596 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45597 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45598 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45680 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45681 fi
45682
45683 # Call helper function which possibly converts this using DOS-style short mode.
45684 # If so, the updated path is stored in $new_path.
45685
45686 input_path="$new_path"
45687 # Check if we need to convert this using DOS-style short mode. If the path
45688 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45689 # take no chances and rewrite it.
45690 # Note: m4 eats our [], so we need to use [ and ] instead.
45691 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45692 if test "x$has_forbidden_chars" != x; then
45693 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45694 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45695 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45696 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45697 # Going to short mode and back again did indeed matter. Since short mode is
45698 # case insensitive, let's make it lowercase to improve readability.
45699 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45700 # Now convert it back to Unix-style (cygpath)
45701 input_path=`$CYGPATH -u "$shortmode_path"`
45702 new_path="$input_path"
45703 fi
45704 fi
45705
45706 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45707 if test "x$test_cygdrive_prefix" = x; then
45708 # As a simple fix, exclude /usr/bin since it's not a real path.
45709 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45710 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45711 # a path prefixed by /cygdrive for fixpath to work.
45712 new_path="$CYGWIN_ROOT_PATH$input_path"
45713 fi
45714 fi
45715
45716
45717 if test "x$path" != "x$new_path"; then
45718 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45719 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45720 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45853 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
45854 fi
45855
45856 # Call helper function which possibly converts this using DOS-style short mode.
45857 # If so, the updated path is stored in $new_path.
45858
45859 input_path="$new_path"
45860 # Check if we need to convert this using DOS-style short mode. If the path
45861 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45862 # take no chances and rewrite it.
45863 # Note: m4 eats our [], so we need to use [ and ] instead.
45864 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45865 if test "x$has_forbidden_chars" != x; then
45866 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45867 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45868 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45869 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45870 # Going to short mode and back again did indeed matter. Since short mode is
45871 # case insensitive, let's make it lowercase to improve readability.
45872 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45873 # Now convert it back to Unix-style (cygpath)
45874 input_path=`$CYGPATH -u "$shortmode_path"`
45875 new_path="$input_path"
45876 fi
45877 fi
45878
45879 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
45880 if test "x$test_cygdrive_prefix" = x; then
45881 # As a simple fix, exclude /usr/bin since it's not a real path.
45882 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
45883 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
45884 # a path prefixed by /cygdrive for fixpath to work.
45885 new_path="$CYGWIN_ROOT_PATH$input_path"
45886 fi
45887 fi
45888
45889
45890 if test "x$path" != "x$new_path"; then
45891 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45892 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45893 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45975 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
45976 fi
45977
45978 # Call helper function which possibly converts this using DOS-style short mode.
45979 # If so, the updated path is stored in $new_path.
45980
45981 input_path="$new_path"
45982 # Check if we need to convert this using DOS-style short mode. If the path
45983 # contains just simple characters, use it. Otherwise (spaces, weird characters),
45984 # take no chances and rewrite it.
45985 # Note: m4 eats our [], so we need to use [ and ] instead.
45986 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
45987 if test "x$has_forbidden_chars" != x; then
45988 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
45989 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
45990 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
45991 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
45992 # Going to short mode and back again did indeed matter. Since short mode is
45993 # case insensitive, let's make it lowercase to improve readability.
45994 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
45995 # Now convert it back to Unix-style (cygpath)
45996 input_path=`$CYGPATH -u "$shortmode_path"`
45997 new_path="$input_path"
45998 fi
45999 fi
46000
46001 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46002 if test "x$test_cygdrive_prefix" = x; then
46003 # As a simple fix, exclude /usr/bin since it's not a real path.
46004 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46005 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46006 # a path prefixed by /cygdrive for fixpath to work.
46007 new_path="$CYGWIN_ROOT_PATH$input_path"
46008 fi
46009 fi
46010
46011
46012 if test "x$path" != "x$new_path"; then
46013 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46014 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46015 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46144 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
46145 fi
46146
46147 # Call helper function which possibly converts this using DOS-style short mode.
46148 # If so, the updated path is stored in $new_path.
46149
46150 input_path="$new_path"
46151 # Check if we need to convert this using DOS-style short mode. If the path
46152 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46153 # take no chances and rewrite it.
46154 # Note: m4 eats our [], so we need to use [ and ] instead.
46155 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46156 if test "x$has_forbidden_chars" != x; then
46157 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46158 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46159 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46160 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46161 # Going to short mode and back again did indeed matter. Since short mode is
46162 # case insensitive, let's make it lowercase to improve readability.
46163 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46164 # Now convert it back to Unix-style (cygpath)
46165 input_path=`$CYGPATH -u "$shortmode_path"`
46166 new_path="$input_path"
46167 fi
46168 fi
46169
46170 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46171 if test "x$test_cygdrive_prefix" = x; then
46172 # As a simple fix, exclude /usr/bin since it's not a real path.
46173 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46174 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46175 # a path prefixed by /cygdrive for fixpath to work.
46176 new_path="$CYGWIN_ROOT_PATH$input_path"
46177 fi
46178 fi
46179
46180
46181 if test "x$path" != "x$new_path"; then
46182 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46183 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46184 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46266 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
46267 fi
46268
46269 # Call helper function which possibly converts this using DOS-style short mode.
46270 # If so, the updated path is stored in $new_path.
46271
46272 input_path="$new_path"
46273 # Check if we need to convert this using DOS-style short mode. If the path
46274 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46275 # take no chances and rewrite it.
46276 # Note: m4 eats our [], so we need to use [ and ] instead.
46277 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46278 if test "x$has_forbidden_chars" != x; then
46279 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46280 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46281 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46282 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46283 # Going to short mode and back again did indeed matter. Since short mode is
46284 # case insensitive, let's make it lowercase to improve readability.
46285 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46286 # Now convert it back to Unix-style (cygpath)
46287 input_path=`$CYGPATH -u "$shortmode_path"`
46288 new_path="$input_path"
46289 fi
46290 fi
46291
46292 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46293 if test "x$test_cygdrive_prefix" = x; then
46294 # As a simple fix, exclude /usr/bin since it's not a real path.
46295 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46296 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46297 # a path prefixed by /cygdrive for fixpath to work.
46298 new_path="$CYGWIN_ROOT_PATH$input_path"
46299 fi
46300 fi
46301
46302
46303 if test "x$path" != "x$new_path"; then
46304 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46305 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46306 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46435 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_INCLUDE_PATH" "$LINENO" 5
46436 fi
46437
46438 # Call helper function which possibly converts this using DOS-style short mode.
46439 # If so, the updated path is stored in $new_path.
46440
46441 input_path="$new_path"
46442 # Check if we need to convert this using DOS-style short mode. If the path
46443 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46444 # take no chances and rewrite it.
46445 # Note: m4 eats our [], so we need to use [ and ] instead.
46446 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46447 if test "x$has_forbidden_chars" != x; then
46448 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46449 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46450 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46451 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46452 # Going to short mode and back again did indeed matter. Since short mode is
46453 # case insensitive, let's make it lowercase to improve readability.
46454 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46455 # Now convert it back to Unix-style (cygpath)
46456 input_path=`$CYGPATH -u "$shortmode_path"`
46457 new_path="$input_path"
46458 fi
46459 fi
46460
46461 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46462 if test "x$test_cygdrive_prefix" = x; then
46463 # As a simple fix, exclude /usr/bin since it's not a real path.
46464 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46465 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46466 # a path prefixed by /cygdrive for fixpath to work.
46467 new_path="$CYGWIN_ROOT_PATH$input_path"
46468 fi
46469 fi
46470
46471
46472 if test "x$path" != "x$new_path"; then
46473 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46474 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46475 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46557 as_fn_error $? "Cannot locate the the path of POTENTIAL_FREETYPE_LIB_PATH" "$LINENO" 5
46558 fi
46559
46560 # Call helper function which possibly converts this using DOS-style short mode.
46561 # If so, the updated path is stored in $new_path.
46562
46563 input_path="$new_path"
46564 # Check if we need to convert this using DOS-style short mode. If the path
46565 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46566 # take no chances and rewrite it.
46567 # Note: m4 eats our [], so we need to use [ and ] instead.
46568 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46569 if test "x$has_forbidden_chars" != x; then
46570 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46571 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46572 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46573 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46574 # Going to short mode and back again did indeed matter. Since short mode is
46575 # case insensitive, let's make it lowercase to improve readability.
46576 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46577 # Now convert it back to Unix-style (cygpath)
46578 input_path=`$CYGPATH -u "$shortmode_path"`
46579 new_path="$input_path"
46580 fi
46581 fi
46582
46583 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46584 if test "x$test_cygdrive_prefix" = x; then
46585 # As a simple fix, exclude /usr/bin since it's not a real path.
46586 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46587 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46588 # a path prefixed by /cygdrive for fixpath to work.
46589 new_path="$CYGWIN_ROOT_PATH$input_path"
46590 fi
46591 fi
46592
46593
46594 if test "x$path" != "x$new_path"; then
46595 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46596 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46597 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46735 as_fn_error $? "Cannot locate the the path of FREETYPE_INCLUDE_PATH" "$LINENO" 5
46736 fi
46737
46738 # Call helper function which possibly converts this using DOS-style short mode.
46739 # If so, the updated path is stored in $new_path.
46740
46741 input_path="$new_path"
46742 # Check if we need to convert this using DOS-style short mode. If the path
46743 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46744 # take no chances and rewrite it.
46745 # Note: m4 eats our [], so we need to use [ and ] instead.
46746 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46747 if test "x$has_forbidden_chars" != x; then
46748 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46749 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46750 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46751 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46752 # Going to short mode and back again did indeed matter. Since short mode is
46753 # case insensitive, let's make it lowercase to improve readability.
46754 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46755 # Now convert it back to Unix-style (cygpath)
46756 input_path=`$CYGPATH -u "$shortmode_path"`
46757 new_path="$input_path"
46758 fi
46759 fi
46760
46761 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46762 if test "x$test_cygdrive_prefix" = x; then
46763 # As a simple fix, exclude /usr/bin since it's not a real path.
46764 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46765 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46766 # a path prefixed by /cygdrive for fixpath to work.
46767 new_path="$CYGWIN_ROOT_PATH$input_path"
46768 fi
46769 fi
46770
46771
46772 if test "x$path" != "x$new_path"; then
46773 FREETYPE_INCLUDE_PATH="$new_path"
46774 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46775 $as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46865 as_fn_error $? "Cannot locate the the path of FREETYPE_LIB_PATH" "$LINENO" 5
46866 fi
46867
46868 # Call helper function which possibly converts this using DOS-style short mode.
46869 # If so, the updated path is stored in $new_path.
46870
46871 input_path="$new_path"
46872 # Check if we need to convert this using DOS-style short mode. If the path
46873 # contains just simple characters, use it. Otherwise (spaces, weird characters),
46874 # take no chances and rewrite it.
46875 # Note: m4 eats our [], so we need to use [ and ] instead.
46876 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
46877 if test "x$has_forbidden_chars" != x; then
46878 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
46879 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
46880 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
46881 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
46882 # Going to short mode and back again did indeed matter. Since short mode is
46883 # case insensitive, let's make it lowercase to improve readability.
46884 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
46885 # Now convert it back to Unix-style (cygpath)
46886 input_path=`$CYGPATH -u "$shortmode_path"`
46887 new_path="$input_path"
46888 fi
46889 fi
46890
46891 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
46892 if test "x$test_cygdrive_prefix" = x; then
46893 # As a simple fix, exclude /usr/bin since it's not a real path.
46894 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
46895 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
46896 # a path prefixed by /cygdrive for fixpath to work.
46897 new_path="$CYGWIN_ROOT_PATH$input_path"
46898 fi
46899 fi
46900
46901
46902 if test "x$path" != "x$new_path"; then
46903 FREETYPE_LIB_PATH="$new_path"
46904 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
46905 $as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
48116 # TODO better (platform agnostic) test
48117 if test "x$OPENJDK_TARGET_OS" = xmacosx && test "x$LIBCXX" = x && test "x$TOOLCHAIN_TYPE" = xgcc; then
48118 LIBCXX="-lstdc++"
48119 fi
48120
48121
48122
48123
48124 if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
48125
48126
48127 # Check whether --with-msvcr-dll was given.
48128 if test "${with_msvcr_dll+set}" = set; then :
48129 withval=$with_msvcr_dll;
48130 fi
48131
48132
48133 if test "x$with_msvcr_dll" != x; then
48134 # If given explicitely by user, do not probe. If not present, fail directly.
48135
48136 DLL_NAME="$MSVCR_NAME"
48137 POSSIBLE_MSVC_DLL="$with_msvcr_dll"
48138 METHOD="--with-msvcr-dll"
48139 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48140 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48141 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48142
48143 # Need to check if the found msvcr is correct architecture
48144 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48145 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48146 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48147 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48148 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48149 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48150 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48151 CORRECT_MSVCR_ARCH="PE32 executable"
48152 else
48153 CORRECT_MSVCR_ARCH="PE32+ executable"
48154 fi
48155 else
48156 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48157 CORRECT_MSVCR_ARCH=386
48158 else
48159 CORRECT_MSVCR_ARCH=x86-64
48160 fi
48161 fi
48162 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48163 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48164 $as_echo "ok" >&6; }
48165 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48166
48167 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48168
48169 # Input might be given as Windows format, start by converting to
48170 # unix format.
48171 path="$MSVC_DLL"
48172 new_path=`$CYGPATH -u "$path"`
48173
48174 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48175 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48176 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48177 # "foo.exe" is OK but "foo" is an error.
48178 #
48179 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48180 # It is also a way to make sure we got the proper file name for the real test later on.
48181 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48182 if test "x$test_shortpath" = x; then
48183 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48184 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48185 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
48186 fi
48187
48188 # Call helper function which possibly converts this using DOS-style short mode.
48189 # If so, the updated path is stored in $new_path.
48190
48191 input_path="$new_path"
48192 # Check if we need to convert this using DOS-style short mode. If the path
48193 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48194 # take no chances and rewrite it.
48195 # Note: m4 eats our [], so we need to use [ and ] instead.
48196 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48197 if test "x$has_forbidden_chars" != x; then
48198 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48199 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48200 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48201 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48202 # Going to short mode and back again did indeed matter. Since short mode is
48203 # case insensitive, let's make it lowercase to improve readability.
48204 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48205 # Now convert it back to Unix-style (cygpath)
48206 input_path=`$CYGPATH -u "$shortmode_path"`
48207 new_path="$input_path"
48208 fi
48209 fi
48210
48211 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48212 if test "x$test_cygdrive_prefix" = x; then
48213 # As a simple fix, exclude /usr/bin since it's not a real path.
48214 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48215 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48216 # a path prefixed by /cygdrive for fixpath to work.
48217 new_path="$CYGWIN_ROOT_PATH$input_path"
48218 fi
48219 fi
48220
48221
48222 if test "x$path" != "x$new_path"; then
48223 MSVC_DLL="$new_path"
48224 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48225 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48226 fi
48227
48228 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48229
48230 path="$MSVC_DLL"
48231 has_colon=`$ECHO $path | $GREP ^.:`
48232 new_path="$path"
48233 if test "x$has_colon" = x; then
48234 # Not in mixed or Windows style, start by that.
48235 new_path=`cmd //c echo $path`
48236 fi
48237
48238
48239 input_path="$new_path"
48240 # Check if we need to convert this using DOS-style short mode. If the path
48241 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48242 # take no chances and rewrite it.
48243 # Note: m4 eats our [], so we need to use [ and ] instead.
48244 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48245 if test "x$has_forbidden_chars" != x; then
48246 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48247 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48248 fi
48249
48250
48251 windows_path="$new_path"
48252 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48253 unix_path=`$CYGPATH -u "$windows_path"`
48254 new_path="$unix_path"
48255 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48256 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48257 new_path="$unix_path"
48258 fi
48259
48260 if test "x$path" != "x$new_path"; then
48261 MSVC_DLL="$new_path"
48262 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48263 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48264 fi
48265
48266 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48267 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48268
48269 else
48270 # We're on a posix platform. Hooray! :)
48271 path="$MSVC_DLL"
48272 has_space=`$ECHO "$path" | $GREP " "`
48273 if test "x$has_space" != x; then
48274 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48275 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48276 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48277 fi
48278
48279 # Use eval to expand a potential ~
48280 eval path="$path"
48281 if test ! -f "$path" && test ! -d "$path"; then
48282 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48283 fi
48284
48285 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
48286 fi
48287
48288 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48289 $as_echo_n "checking for $DLL_NAME... " >&6; }
48290 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48291 $as_echo "$MSVC_DLL" >&6; }
48292 else
48293 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48294 $as_echo "incorrect, ignoring" >&6; }
48295 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48296 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48297 fi
48298 fi
48299
48300 if test "x$MSVC_DLL" = x; then
48301 as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by --with-msvcr-dll" "$LINENO" 5
48302 fi
48303 MSVCR_DLL="$MSVC_DLL"
48304 elif test "x$DEVKIT_MSVCR_DLL" != x; then
48305
48306 DLL_NAME="$MSVCR_NAME"
48307 POSSIBLE_MSVC_DLL="$DEVKIT_MSVCR_DLL"
48308 METHOD="devkit"
48309 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48310 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48311 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48312
48313 # Need to check if the found msvcr is correct architecture
48314 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48315 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48316 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48317 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48318 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48319 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48320 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48321 CORRECT_MSVCR_ARCH="PE32 executable"
48322 else
48323 CORRECT_MSVCR_ARCH="PE32+ executable"
48324 fi
48325 else
48326 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48327 CORRECT_MSVCR_ARCH=386
48328 else
48329 CORRECT_MSVCR_ARCH=x86-64
48330 fi
48331 fi
48332 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48333 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48334 $as_echo "ok" >&6; }
48335 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48336
48337 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48338
48339 # Input might be given as Windows format, start by converting to
48340 # unix format.
48341 path="$MSVC_DLL"
48342 new_path=`$CYGPATH -u "$path"`
48343
48344 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48345 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48346 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48347 # "foo.exe" is OK but "foo" is an error.
48348 #
48349 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48350 # It is also a way to make sure we got the proper file name for the real test later on.
48351 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48352 if test "x$test_shortpath" = x; then
48353 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48354 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48355 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
48356 fi
48357
48358 # Call helper function which possibly converts this using DOS-style short mode.
48359 # If so, the updated path is stored in $new_path.
48360
48361 input_path="$new_path"
48362 # Check if we need to convert this using DOS-style short mode. If the path
48363 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48364 # take no chances and rewrite it.
48365 # Note: m4 eats our [], so we need to use [ and ] instead.
48366 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48367 if test "x$has_forbidden_chars" != x; then
48368 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48369 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48370 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48371 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48372 # Going to short mode and back again did indeed matter. Since short mode is
48373 # case insensitive, let's make it lowercase to improve readability.
48374 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48375 # Now convert it back to Unix-style (cygpath)
48376 input_path=`$CYGPATH -u "$shortmode_path"`
48377 new_path="$input_path"
48378 fi
48379 fi
48380
48381 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48382 if test "x$test_cygdrive_prefix" = x; then
48383 # As a simple fix, exclude /usr/bin since it's not a real path.
48384 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48385 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48386 # a path prefixed by /cygdrive for fixpath to work.
48387 new_path="$CYGWIN_ROOT_PATH$input_path"
48388 fi
48389 fi
48390
48391
48392 if test "x$path" != "x$new_path"; then
48393 MSVC_DLL="$new_path"
48394 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48395 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48396 fi
48397
48398 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48399
48400 path="$MSVC_DLL"
48401 has_colon=`$ECHO $path | $GREP ^.:`
48402 new_path="$path"
48403 if test "x$has_colon" = x; then
48404 # Not in mixed or Windows style, start by that.
48405 new_path=`cmd //c echo $path`
48406 fi
48407
48408
48409 input_path="$new_path"
48410 # Check if we need to convert this using DOS-style short mode. If the path
48411 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48412 # take no chances and rewrite it.
48413 # Note: m4 eats our [], so we need to use [ and ] instead.
48414 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48415 if test "x$has_forbidden_chars" != x; then
48416 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48417 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48418 fi
48419
48420
48421 windows_path="$new_path"
48422 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48423 unix_path=`$CYGPATH -u "$windows_path"`
48424 new_path="$unix_path"
48425 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48426 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48427 new_path="$unix_path"
48428 fi
48429
48430 if test "x$path" != "x$new_path"; then
48431 MSVC_DLL="$new_path"
48432 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48433 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48434 fi
48435
48436 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48437 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48438
48439 else
48440 # We're on a posix platform. Hooray! :)
48441 path="$MSVC_DLL"
48442 has_space=`$ECHO "$path" | $GREP " "`
48443 if test "x$has_space" != x; then
48444 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48445 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48446 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48447 fi
48448
48449 # Use eval to expand a potential ~
48450 eval path="$path"
48451 if test ! -f "$path" && test ! -d "$path"; then
48452 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48453 fi
48454
48455 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
48456 fi
48457
48458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48459 $as_echo_n "checking for $DLL_NAME... " >&6; }
48460 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48461 $as_echo "$MSVC_DLL" >&6; }
48462 else
48463 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48464 $as_echo "incorrect, ignoring" >&6; }
48465 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48466 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48467 fi
48468 fi
48469
48470 if test "x$MSVC_DLL" = x; then
48471 as_fn_error $? "Could not find a proper $MSVCR_NAME as specified by devkit" "$LINENO" 5
48472 fi
48473 MSVCR_DLL="$MSVC_DLL"
48474 else
48475
48476 DLL_NAME="${MSVCR_NAME}"
48477 MSVC_DLL=
48478
48479 if test "x$MSVC_DLL" = x; then
48480 # Probe: Using well-known location from Visual Studio 10.0
48481 if test "x$VCINSTALLDIR" != x; then
48482 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
48483
48484 windows_path="$CYGWIN_VC_INSTALL_DIR"
48485 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48486 unix_path=`$CYGPATH -u "$windows_path"`
48487 CYGWIN_VC_INSTALL_DIR="$unix_path"
48488 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48489 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48490 CYGWIN_VC_INSTALL_DIR="$unix_path"
48491 fi
48492
48493 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
48494 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
48495 else
48496 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
48497 fi
48498 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
48499
48500 DLL_NAME="$DLL_NAME"
48501 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48502 METHOD="well-known location in VCINSTALLDIR"
48503 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48504 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48505 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48506
48507 # Need to check if the found msvcr is correct architecture
48508 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48509 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48510 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48511 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48512 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48513 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48514 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48515 CORRECT_MSVCR_ARCH="PE32 executable"
48516 else
48517 CORRECT_MSVCR_ARCH="PE32+ executable"
48518 fi
48519 else
48520 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48521 CORRECT_MSVCR_ARCH=386
48522 else
48523 CORRECT_MSVCR_ARCH=x86-64
48524 fi
48525 fi
48526 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48527 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48528 $as_echo "ok" >&6; }
48529 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48530
48531 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48532
48533 # Input might be given as Windows format, start by converting to
48534 # unix format.
48535 path="$MSVC_DLL"
48536 new_path=`$CYGPATH -u "$path"`
48537
48538 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48539 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48540 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48541 # "foo.exe" is OK but "foo" is an error.
48542 #
48543 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48544 # It is also a way to make sure we got the proper file name for the real test later on.
48545 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48546 if test "x$test_shortpath" = x; then
48547 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48548 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48549 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
48550 fi
48551
48552 # Call helper function which possibly converts this using DOS-style short mode.
48553 # If so, the updated path is stored in $new_path.
48554
48555 input_path="$new_path"
48556 # Check if we need to convert this using DOS-style short mode. If the path
48557 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48558 # take no chances and rewrite it.
48559 # Note: m4 eats our [], so we need to use [ and ] instead.
48560 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48561 if test "x$has_forbidden_chars" != x; then
48562 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48563 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48564 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48565 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48566 # Going to short mode and back again did indeed matter. Since short mode is
48567 # case insensitive, let's make it lowercase to improve readability.
48568 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48569 # Now convert it back to Unix-style (cygpath)
48570 input_path=`$CYGPATH -u "$shortmode_path"`
48571 new_path="$input_path"
48572 fi
48573 fi
48574
48575 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48576 if test "x$test_cygdrive_prefix" = x; then
48577 # As a simple fix, exclude /usr/bin since it's not a real path.
48578 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48579 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48580 # a path prefixed by /cygdrive for fixpath to work.
48581 new_path="$CYGWIN_ROOT_PATH$input_path"
48582 fi
48583 fi
48584
48585
48586 if test "x$path" != "x$new_path"; then
48587 MSVC_DLL="$new_path"
48588 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48589 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48590 fi
48591
48592 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48593
48594 path="$MSVC_DLL"
48595 has_colon=`$ECHO $path | $GREP ^.:`
48596 new_path="$path"
48597 if test "x$has_colon" = x; then
48598 # Not in mixed or Windows style, start by that.
48599 new_path=`cmd //c echo $path`
48600 fi
48601
48602
48603 input_path="$new_path"
48604 # Check if we need to convert this using DOS-style short mode. If the path
48605 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48606 # take no chances and rewrite it.
48607 # Note: m4 eats our [], so we need to use [ and ] instead.
48608 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48609 if test "x$has_forbidden_chars" != x; then
48610 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48611 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48612 fi
48613
48614
48615 windows_path="$new_path"
48616 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48617 unix_path=`$CYGPATH -u "$windows_path"`
48618 new_path="$unix_path"
48619 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48620 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48621 new_path="$unix_path"
48622 fi
48623
48624 if test "x$path" != "x$new_path"; then
48625 MSVC_DLL="$new_path"
48626 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48627 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48628 fi
48629
48630 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48631 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48632
48633 else
48634 # We're on a posix platform. Hooray! :)
48635 path="$MSVC_DLL"
48636 has_space=`$ECHO "$path" | $GREP " "`
48637 if test "x$has_space" != x; then
48638 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48639 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48640 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48641 fi
48642
48643 # Use eval to expand a potential ~
48644 eval path="$path"
48645 if test ! -f "$path" && test ! -d "$path"; then
48646 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48647 fi
48648
48649 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
48650 fi
48651
48652 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48653 $as_echo_n "checking for $DLL_NAME... " >&6; }
48654 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48655 $as_echo "$MSVC_DLL" >&6; }
48656 else
48657 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48658 $as_echo "incorrect, ignoring" >&6; }
48659 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48660 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48661 fi
48662 fi
48663
48664 fi
48665 fi
48666
48667 if test "x$MSVC_DLL" = x; then
48668 # Probe: Check in the Boot JDK directory.
48669 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
48670
48671 DLL_NAME="$DLL_NAME"
48672 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48673 METHOD="well-known location in Boot JDK"
48674 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48675 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48676 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48677
48678 # Need to check if the found msvcr is correct architecture
48679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48680 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48681 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48682 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48683 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48684 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48685 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48686 CORRECT_MSVCR_ARCH="PE32 executable"
48687 else
48688 CORRECT_MSVCR_ARCH="PE32+ executable"
48689 fi
48690 else
48691 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48692 CORRECT_MSVCR_ARCH=386
48693 else
48694 CORRECT_MSVCR_ARCH=x86-64
48695 fi
48696 fi
48697 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48698 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48699 $as_echo "ok" >&6; }
48700 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48701
48702 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48703
48704 # Input might be given as Windows format, start by converting to
48705 # unix format.
48706 path="$MSVC_DLL"
48707 new_path=`$CYGPATH -u "$path"`
48708
48709 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48710 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48711 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48712 # "foo.exe" is OK but "foo" is an error.
48713 #
48714 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48715 # It is also a way to make sure we got the proper file name for the real test later on.
48716 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48717 if test "x$test_shortpath" = x; then
48718 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48719 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48720 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
48721 fi
48722
48723 # Call helper function which possibly converts this using DOS-style short mode.
48724 # If so, the updated path is stored in $new_path.
48725
48726 input_path="$new_path"
48727 # Check if we need to convert this using DOS-style short mode. If the path
48728 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48729 # take no chances and rewrite it.
48730 # Note: m4 eats our [], so we need to use [ and ] instead.
48731 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48732 if test "x$has_forbidden_chars" != x; then
48733 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48734 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48735 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48736 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48737 # Going to short mode and back again did indeed matter. Since short mode is
48738 # case insensitive, let's make it lowercase to improve readability.
48739 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48740 # Now convert it back to Unix-style (cygpath)
48741 input_path=`$CYGPATH -u "$shortmode_path"`
48742 new_path="$input_path"
48743 fi
48744 fi
48745
48746 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48747 if test "x$test_cygdrive_prefix" = x; then
48748 # As a simple fix, exclude /usr/bin since it's not a real path.
48749 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48750 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48751 # a path prefixed by /cygdrive for fixpath to work.
48752 new_path="$CYGWIN_ROOT_PATH$input_path"
48753 fi
48754 fi
48755
48756
48757 if test "x$path" != "x$new_path"; then
48758 MSVC_DLL="$new_path"
48759 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48760 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48761 fi
48762
48763 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48764
48765 path="$MSVC_DLL"
48766 has_colon=`$ECHO $path | $GREP ^.:`
48767 new_path="$path"
48768 if test "x$has_colon" = x; then
48769 # Not in mixed or Windows style, start by that.
48770 new_path=`cmd //c echo $path`
48771 fi
48772
48773
48774 input_path="$new_path"
48775 # Check if we need to convert this using DOS-style short mode. If the path
48776 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48777 # take no chances and rewrite it.
48778 # Note: m4 eats our [], so we need to use [ and ] instead.
48779 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48780 if test "x$has_forbidden_chars" != x; then
48781 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48782 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48783 fi
48784
48785
48786 windows_path="$new_path"
48787 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48788 unix_path=`$CYGPATH -u "$windows_path"`
48789 new_path="$unix_path"
48790 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48791 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48792 new_path="$unix_path"
48793 fi
48794
48795 if test "x$path" != "x$new_path"; then
48796 MSVC_DLL="$new_path"
48797 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48798 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48799 fi
48800
48801 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48802 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48803
48804 else
48805 # We're on a posix platform. Hooray! :)
48806 path="$MSVC_DLL"
48807 has_space=`$ECHO "$path" | $GREP " "`
48808 if test "x$has_space" != x; then
48809 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48810 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48811 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48812 fi
48813
48814 # Use eval to expand a potential ~
48815 eval path="$path"
48816 if test ! -f "$path" && test ! -d "$path"; then
48817 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48818 fi
48819
48820 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
48821 fi
48822
48823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
48824 $as_echo_n "checking for $DLL_NAME... " >&6; }
48825 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
48826 $as_echo "$MSVC_DLL" >&6; }
48827 else
48828 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
48829 $as_echo "incorrect, ignoring" >&6; }
48830 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
48831 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
48832 fi
48833 fi
48834
48835 fi
48836
48837 if test "x$MSVC_DLL" = x; then
48838 # Probe: Look in the Windows system32 directory
48839 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
48840
48841 windows_path="$CYGWIN_SYSTEMROOT"
48842 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48843 unix_path=`$CYGPATH -u "$windows_path"`
48844 CYGWIN_SYSTEMROOT="$unix_path"
48845 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48846 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48847 CYGWIN_SYSTEMROOT="$unix_path"
48848 fi
48849
48850 POSSIBLE_MSVC_DLL="$CYGWIN_SYSTEMROOT/system32/$DLL_NAME"
48851
48852 DLL_NAME="$DLL_NAME"
48853 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
48854 METHOD="well-known location in SYSTEMROOT"
48855 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
48856 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
48857 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
48858
48859 # Need to check if the found msvcr is correct architecture
48860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
48861 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
48862 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
48863 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48864 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
48865 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
48866 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48867 CORRECT_MSVCR_ARCH="PE32 executable"
48868 else
48869 CORRECT_MSVCR_ARCH="PE32+ executable"
48870 fi
48871 else
48872 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
48873 CORRECT_MSVCR_ARCH=386
48874 else
48875 CORRECT_MSVCR_ARCH=x86-64
48876 fi
48877 fi
48878 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
48879 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
48880 $as_echo "ok" >&6; }
48881 MSVC_DLL="$POSSIBLE_MSVC_DLL"
48882
48883 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48884
48885 # Input might be given as Windows format, start by converting to
48886 # unix format.
48887 path="$MSVC_DLL"
48888 new_path=`$CYGPATH -u "$path"`
48889
48890 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
48891 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
48892 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
48893 # "foo.exe" is OK but "foo" is an error.
48894 #
48895 # This test is therefore slightly more accurate than "test -f" to check for file precense.
48896 # It is also a way to make sure we got the proper file name for the real test later on.
48897 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
48898 if test "x$test_shortpath" = x; then
48899 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48900 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48901 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
48902 fi
48903
48904 # Call helper function which possibly converts this using DOS-style short mode.
48905 # If so, the updated path is stored in $new_path.
48906
48907 input_path="$new_path"
48908 # Check if we need to convert this using DOS-style short mode. If the path
48909 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48910 # take no chances and rewrite it.
48911 # Note: m4 eats our [], so we need to use [ and ] instead.
48912 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
48913 if test "x$has_forbidden_chars" != x; then
48914 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48915 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
48916 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
48917 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
48918 # Going to short mode and back again did indeed matter. Since short mode is
48919 # case insensitive, let's make it lowercase to improve readability.
48920 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48921 # Now convert it back to Unix-style (cygpath)
48922 input_path=`$CYGPATH -u "$shortmode_path"`
48923 new_path="$input_path"
48924 fi
48925 fi
48926
48927 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
48928 if test "x$test_cygdrive_prefix" = x; then
48929 # As a simple fix, exclude /usr/bin since it's not a real path.
48930 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
48931 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
48932 # a path prefixed by /cygdrive for fixpath to work.
48933 new_path="$CYGWIN_ROOT_PATH$input_path"
48934 fi
48935 fi
48936
48937
48938 if test "x$path" != "x$new_path"; then
48939 MSVC_DLL="$new_path"
48940 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48941 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48942 fi
48943
48944 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48945
48946 path="$MSVC_DLL"
48947 has_colon=`$ECHO $path | $GREP ^.:`
48948 new_path="$path"
48949 if test "x$has_colon" = x; then
48950 # Not in mixed or Windows style, start by that.
48951 new_path=`cmd //c echo $path`
48952 fi
48953
48954
48955 input_path="$new_path"
48956 # Check if we need to convert this using DOS-style short mode. If the path
48957 # contains just simple characters, use it. Otherwise (spaces, weird characters),
48958 # take no chances and rewrite it.
48959 # Note: m4 eats our [], so we need to use [ and ] instead.
48960 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
48961 if test "x$has_forbidden_chars" != x; then
48962 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
48963 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
48964 fi
48965
48966
48967 windows_path="$new_path"
48968 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48969 unix_path=`$CYGPATH -u "$windows_path"`
48970 new_path="$unix_path"
48971 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48972 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48973 new_path="$unix_path"
48974 fi
48975
48976 if test "x$path" != "x$new_path"; then
48977 MSVC_DLL="$new_path"
48978 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
48979 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
48980 fi
48981
48982 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48983 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48984
48985 else
48986 # We're on a posix platform. Hooray! :)
48987 path="$MSVC_DLL"
48988 has_space=`$ECHO "$path" | $GREP " "`
48989 if test "x$has_space" != x; then
48990 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
48991 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
48992 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48993 fi
48994
48995 # Use eval to expand a potential ~
48996 eval path="$path"
48997 if test ! -f "$path" && test ! -d "$path"; then
48998 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
48999 fi
49000
49001 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
49002 fi
49003
49004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49005 $as_echo_n "checking for $DLL_NAME... " >&6; }
49006 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49007 $as_echo "$MSVC_DLL" >&6; }
49008 else
49009 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49010 $as_echo "incorrect, ignoring" >&6; }
49011 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49012 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49013 fi
49014 fi
49015
49016 fi
49017
49018 if test "x$MSVC_DLL" = x; then
49019 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
49020 if test "x$VS100COMNTOOLS" != x; then
49021 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
49022
49023 windows_path="$CYGWIN_VS_TOOLS_DIR"
49024 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49025 unix_path=`$CYGPATH -u "$windows_path"`
49026 CYGWIN_VS_TOOLS_DIR="$unix_path"
49027 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49028 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49029 CYGWIN_VS_TOOLS_DIR="$unix_path"
49030 fi
49031
49032 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49033 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
49034 | $GREP -i /x64/ | $HEAD --lines 1`
49035 else
49036 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VS_TOOLS_DIR" -name $DLL_NAME \
49037 | $GREP -i /x86/ | $HEAD --lines 1`
49038 fi
49039
49040 DLL_NAME="$DLL_NAME"
49041 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
49042 METHOD="search of VS100COMNTOOLS"
49043 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49044 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49045 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49046
49047 # Need to check if the found msvcr is correct architecture
49048 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49049 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49050 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49051 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49052 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49053 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49054 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49055 CORRECT_MSVCR_ARCH="PE32 executable"
49056 else
49057 CORRECT_MSVCR_ARCH="PE32+ executable"
49058 fi
49059 else
49060 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49061 CORRECT_MSVCR_ARCH=386
49062 else
49063 CORRECT_MSVCR_ARCH=x86-64
49064 fi
49065 fi
49066 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49067 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49068 $as_echo "ok" >&6; }
49069 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49070
49071 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49072
49073 # Input might be given as Windows format, start by converting to
49074 # unix format.
49075 path="$MSVC_DLL"
49076 new_path=`$CYGPATH -u "$path"`
49077
49078 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49079 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49080 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49081 # "foo.exe" is OK but "foo" is an error.
49082 #
49083 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49084 # It is also a way to make sure we got the proper file name for the real test later on.
49085 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49086 if test "x$test_shortpath" = x; then
49087 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49088 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49089 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
49090 fi
49091
49092 # Call helper function which possibly converts this using DOS-style short mode.
49093 # If so, the updated path is stored in $new_path.
49094
49095 input_path="$new_path"
49096 # Check if we need to convert this using DOS-style short mode. If the path
49097 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49098 # take no chances and rewrite it.
49099 # Note: m4 eats our [], so we need to use [ and ] instead.
49100 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
49101 if test "x$has_forbidden_chars" != x; then
49102 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49103 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
49104 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
49105 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
49106 # Going to short mode and back again did indeed matter. Since short mode is
49107 # case insensitive, let's make it lowercase to improve readability.
49108 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49109 # Now convert it back to Unix-style (cygpath)
49110 input_path=`$CYGPATH -u "$shortmode_path"`
49111 new_path="$input_path"
49112 fi
49113 fi
49114
49115 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
49116 if test "x$test_cygdrive_prefix" = x; then
49117 # As a simple fix, exclude /usr/bin since it's not a real path.
49118 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
49119 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
49120 # a path prefixed by /cygdrive for fixpath to work.
49121 new_path="$CYGWIN_ROOT_PATH$input_path"
49122 fi
49123 fi
49124
49125
49126 if test "x$path" != "x$new_path"; then
49127 MSVC_DLL="$new_path"
49128 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49129 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49130 fi
49131
49132 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49133
49134 path="$MSVC_DLL"
49135 has_colon=`$ECHO $path | $GREP ^.:`
49136 new_path="$path"
49137 if test "x$has_colon" = x; then
49138 # Not in mixed or Windows style, start by that.
49139 new_path=`cmd //c echo $path`
49140 fi
49141
49142
49143 input_path="$new_path"
49144 # Check if we need to convert this using DOS-style short mode. If the path
49145 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49146 # take no chances and rewrite it.
49147 # Note: m4 eats our [], so we need to use [ and ] instead.
49148 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
49149 if test "x$has_forbidden_chars" != x; then
49150 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49151 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49152 fi
49153
49154
49155 windows_path="$new_path"
49156 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49157 unix_path=`$CYGPATH -u "$windows_path"`
49158 new_path="$unix_path"
49159 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49160 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49161 new_path="$unix_path"
49162 fi
49163
49164 if test "x$path" != "x$new_path"; then
49165 MSVC_DLL="$new_path"
49166 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49167 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49168 fi
49169
49170 # Save the first 10 bytes of this path to the storage, so fixpath can work.
49171 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
49172
49173 else
49174 # We're on a posix platform. Hooray! :)
49175 path="$MSVC_DLL"
49176 has_space=`$ECHO "$path" | $GREP " "`
49177 if test "x$has_space" != x; then
49178 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49179 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49180 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
49181 fi
49182
49183 # Use eval to expand a potential ~
49184 eval path="$path"
49185 if test ! -f "$path" && test ! -d "$path"; then
49186 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
49187 fi
49188
49189 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
49190 fi
49191
49192 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49193 $as_echo_n "checking for $DLL_NAME... " >&6; }
49194 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49195 $as_echo "$MSVC_DLL" >&6; }
49196 else
49197 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49198 $as_echo "incorrect, ignoring" >&6; }
49199 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49200 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49201 fi
49202 fi
49203
49204 fi
49205 fi
49206
49207 if test "x$MSVC_DLL" = x; then
49208 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
49209 # (This was the original behaviour; kept since it might turn something up)
49210 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
49211 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49212 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
49213 | $GREP x64 | $HEAD --lines 1`
49214 else
49215 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
49216 | $GREP x86 | $GREP -v ia64 | $GREP -v x64 | $HEAD --lines 1`
49217 if test "x$POSSIBLE_MSVC_DLL" = x; then
49218 # We're grasping at straws now...
49219 POSSIBLE_MSVC_DLL=`$FIND "$CYGWIN_VC_INSTALL_DIR" -name $DLL_NAME \
49220 | $HEAD --lines 1`
49221 fi
49222 fi
49223
49224
49225 DLL_NAME="$DLL_NAME"
49226 POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
49227 METHOD="search of VCINSTALLDIR"
49228 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49229 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49230 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49231
49232 # Need to check if the found msvcr is correct architecture
49233 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49234 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49235 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49236 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49237 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49238 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49239 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49240 CORRECT_MSVCR_ARCH="PE32 executable"
49241 else
49242 CORRECT_MSVCR_ARCH="PE32+ executable"
49243 fi
49244 else
49245 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49246 CORRECT_MSVCR_ARCH=386
49247 else
49248 CORRECT_MSVCR_ARCH=x86-64
49249 fi
49250 fi
49251 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49252 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49253 $as_echo "ok" >&6; }
49254 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49255
49256 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49257
49258 # Input might be given as Windows format, start by converting to
49259 # unix format.
49260 path="$MSVC_DLL"
49261 new_path=`$CYGPATH -u "$path"`
49262
49263 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49264 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49265 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49266 # "foo.exe" is OK but "foo" is an error.
49267 #
49268 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49269 # It is also a way to make sure we got the proper file name for the real test later on.
49270 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49271 if test "x$test_shortpath" = x; then
49272 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49273 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49274 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
49275 fi
49276
49277 # Call helper function which possibly converts this using DOS-style short mode.
49278 # If so, the updated path is stored in $new_path.
49279
49280 input_path="$new_path"
49281 # Check if we need to convert this using DOS-style short mode. If the path
49282 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49283 # take no chances and rewrite it.
49284 # Note: m4 eats our [], so we need to use [ and ] instead.
49285 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
49286 if test "x$has_forbidden_chars" != x; then
49287 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49288 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
49289 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
49290 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
49291 # Going to short mode and back again did indeed matter. Since short mode is
49292 # case insensitive, let's make it lowercase to improve readability.
49293 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49294 # Now convert it back to Unix-style (cygpath)
49295 input_path=`$CYGPATH -u "$shortmode_path"`
49296 new_path="$input_path"
49297 fi
49298 fi
49299
49300 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
49301 if test "x$test_cygdrive_prefix" = x; then
49302 # As a simple fix, exclude /usr/bin since it's not a real path.
49303 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
49304 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
49305 # a path prefixed by /cygdrive for fixpath to work.
49306 new_path="$CYGWIN_ROOT_PATH$input_path"
49307 fi
49308 fi
49309
49310
49311 if test "x$path" != "x$new_path"; then
49312 MSVC_DLL="$new_path"
49313 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49314 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49315 fi
49316
49317 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49318
49319 path="$MSVC_DLL"
49320 has_colon=`$ECHO $path | $GREP ^.:`
49321 new_path="$path"
49322 if test "x$has_colon" = x; then
49323 # Not in mixed or Windows style, start by that.
49324 new_path=`cmd //c echo $path`
49325 fi
49326
49327
49328 input_path="$new_path"
49329 # Check if we need to convert this using DOS-style short mode. If the path
49330 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49331 # take no chances and rewrite it.
49332 # Note: m4 eats our [], so we need to use [ and ] instead.
49333 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
49334 if test "x$has_forbidden_chars" != x; then
49335 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49336 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49337 fi
49338
49339
49340 windows_path="$new_path"
49341 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49342 unix_path=`$CYGPATH -u "$windows_path"`
49343 new_path="$unix_path"
49344 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49345 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49346 new_path="$unix_path"
49347 fi
49348
49349 if test "x$path" != "x$new_path"; then
49350 MSVC_DLL="$new_path"
49351 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49352 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49353 fi
49354
49355 # Save the first 10 bytes of this path to the storage, so fixpath can work.
49356 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
49357
49358 else
49359 # We're on a posix platform. Hooray! :)
49360 path="$MSVC_DLL"
49361 has_space=`$ECHO "$path" | $GREP " "`
49362 if test "x$has_space" != x; then
49363 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49364 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49365 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
49366 fi
49367
49368 # Use eval to expand a potential ~
49369 eval path="$path"
49370 if test ! -f "$path" && test ! -d "$path"; then
49371 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
49372 fi
49373
49374 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
49375 fi
49376
49377 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49378 $as_echo_n "checking for $DLL_NAME... " >&6; }
49379 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49380 $as_echo "$MSVC_DLL" >&6; }
49381 else
49382 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49383 $as_echo "incorrect, ignoring" >&6; }
49384 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49385 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49386 fi
49387 fi
49388
49389 fi
49390 fi
49391
49392 if test "x$MSVC_DLL" = x; then
49393 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49394 $as_echo_n "checking for $DLL_NAME... " >&6; }
49395 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
49396 $as_echo "no" >&6; }
49397 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
49398 fi
49399
49400 MSVCR_DLL="$MSVC_DLL"
49401 fi
49402
49403
49404
49405 # Check whether --with-msvcp-dll was given.
49406 if test "${with_msvcp_dll+set}" = set; then :
49407 withval=$with_msvcp_dll;
49408 fi
49409
49410
49411 if test "x$MSVCP_NAME" != "x"; then
49412 if test "x$with_msvcp_dll" != x; then
49413 # If given explicitely by user, do not probe. If not present, fail directly.
49414
49415 DLL_NAME="$MSVCP_NAME"
49416 POSSIBLE_MSVC_DLL="$with_msvcp_dll"
49417 METHOD="--with-msvcp-dll"
49418 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49419 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49420 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49421
49422 # Need to check if the found msvcr is correct architecture
49423 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49424 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49425 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49426 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49427 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49428 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49429 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49430 CORRECT_MSVCR_ARCH="PE32 executable"
49431 else
49432 CORRECT_MSVCR_ARCH="PE32+ executable"
49433 fi
49434 else
49435 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49436 CORRECT_MSVCR_ARCH=386
49437 else
49438 CORRECT_MSVCR_ARCH=x86-64
49439 fi
49440 fi
49441 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49442 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49443 $as_echo "ok" >&6; }
49444 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49445
49446 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49447
49448 # Input might be given as Windows format, start by converting to
49449 # unix format.
49450 path="$MSVC_DLL"
49451 new_path=`$CYGPATH -u "$path"`
49452
49453 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49454 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49455 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49456 # "foo.exe" is OK but "foo" is an error.
49457 #
49458 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49459 # It is also a way to make sure we got the proper file name for the real test later on.
49460 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49461 if test "x$test_shortpath" = x; then
49462 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49463 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49464 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
49465 fi
49466
49467 # Call helper function which possibly converts this using DOS-style short mode.
49468 # If so, the updated path is stored in $new_path.
49469
49470 input_path="$new_path"
49471 # Check if we need to convert this using DOS-style short mode. If the path
49472 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49473 # take no chances and rewrite it.
49474 # Note: m4 eats our [], so we need to use [ and ] instead.
49475 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
49476 if test "x$has_forbidden_chars" != x; then
49477 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49478 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
49479 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
49480 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
49481 # Going to short mode and back again did indeed matter. Since short mode is
49482 # case insensitive, let's make it lowercase to improve readability.
49483 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49484 # Now convert it back to Unix-style (cygpath)
49485 input_path=`$CYGPATH -u "$shortmode_path"`
49486 new_path="$input_path"
49487 fi
49488 fi
49489
49490 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
49491 if test "x$test_cygdrive_prefix" = x; then
49492 # As a simple fix, exclude /usr/bin since it's not a real path.
49493 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
49494 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
49495 # a path prefixed by /cygdrive for fixpath to work.
49496 new_path="$CYGWIN_ROOT_PATH$input_path"
49497 fi
49498 fi
49499
49500
49501 if test "x$path" != "x$new_path"; then
49502 MSVC_DLL="$new_path"
49503 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49504 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49505 fi
49506
49507 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49508
49509 path="$MSVC_DLL"
49510 has_colon=`$ECHO $path | $GREP ^.:`
49511 new_path="$path"
49512 if test "x$has_colon" = x; then
49513 # Not in mixed or Windows style, start by that.
49514 new_path=`cmd //c echo $path`
49515 fi
49516
49517
49518 input_path="$new_path"
49519 # Check if we need to convert this using DOS-style short mode. If the path
49520 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49521 # take no chances and rewrite it.
49522 # Note: m4 eats our [], so we need to use [ and ] instead.
49523 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
49524 if test "x$has_forbidden_chars" != x; then
49525 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49526 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49527 fi
49528
49529
49530 windows_path="$new_path"
49531 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49532 unix_path=`$CYGPATH -u "$windows_path"`
49533 new_path="$unix_path"
49534 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49535 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49536 new_path="$unix_path"
49537 fi
49538
49539 if test "x$path" != "x$new_path"; then
49540 MSVC_DLL="$new_path"
49541 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49542 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49543 fi
49544
49545 # Save the first 10 bytes of this path to the storage, so fixpath can work.
49546 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
49547
49548 else
49549 # We're on a posix platform. Hooray! :)
49550 path="$MSVC_DLL"
49551 has_space=`$ECHO "$path" | $GREP " "`
49552 if test "x$has_space" != x; then
49553 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49554 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49555 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
49556 fi
49557
49558 # Use eval to expand a potential ~
49559 eval path="$path"
49560 if test ! -f "$path" && test ! -d "$path"; then
49561 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
49562 fi
49563
49564 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
49565 fi
49566
49567 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49568 $as_echo_n "checking for $DLL_NAME... " >&6; }
49569 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49570 $as_echo "$MSVC_DLL" >&6; }
49571 else
49572 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49573 $as_echo "incorrect, ignoring" >&6; }
49574 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49575 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49576 fi
49577 fi
49578
49579 if test "x$MSVC_DLL" = x; then
49580 as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by --with-msvcp-dll" "$LINENO" 5
49581 fi
49582 MSVCP_DLL="$MSVC_DLL"
49583 elif test "x$DEVKIT_MSVCP_DLL" != x; then
49584
49585 DLL_NAME="$MSVCP_NAME"
49586 POSSIBLE_MSVC_DLL="$DEVKIT_MSVCP_DLL"
49587 METHOD="devkit"
49588 if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
49589 { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
49590 $as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
49591
49592 # Need to check if the found msvcr is correct architecture
49593 { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
49594 $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
49595 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49596 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49597 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49598 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49599 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49600 CORRECT_MSVCR_ARCH="PE32 executable"
49601 else
49602 CORRECT_MSVCR_ARCH="PE32+ executable"
49603 fi
49604 else
49605 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49606 CORRECT_MSVCR_ARCH=386
49607 else
49608 CORRECT_MSVCR_ARCH=x86-64
49609 fi
49610 fi
49611 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49612 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49613 $as_echo "ok" >&6; }
49614 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49615
49616 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49617
49618 # Input might be given as Windows format, start by converting to
49619 # unix format.
49620 path="$MSVC_DLL"
49621 new_path=`$CYGPATH -u "$path"`
49622
49623 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49624 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49625 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49626 # "foo.exe" is OK but "foo" is an error.
49627 #
49628 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49629 # It is also a way to make sure we got the proper file name for the real test later on.
49630 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49631 if test "x$test_shortpath" = x; then
49632 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49633 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49634 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
49635 fi
49636
49637 # Call helper function which possibly converts this using DOS-style short mode.
49638 # If so, the updated path is stored in $new_path.
49639
49640 input_path="$new_path"
49641 # Check if we need to convert this using DOS-style short mode. If the path
49642 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49643 # take no chances and rewrite it.
49644 # Note: m4 eats our [], so we need to use [ and ] instead.
49645 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
49646 if test "x$has_forbidden_chars" != x; then
49647 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49648 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
49649 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
49650 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
49651 # Going to short mode and back again did indeed matter. Since short mode is
49652 # case insensitive, let's make it lowercase to improve readability.
49653 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49654 # Now convert it back to Unix-style (cygpath)
49655 input_path=`$CYGPATH -u "$shortmode_path"`
49656 new_path="$input_path"
49657 fi
49658 fi
49659
49660 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
49661 if test "x$test_cygdrive_prefix" = x; then
49662 # As a simple fix, exclude /usr/bin since it's not a real path.
49663 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
49664 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
49665 # a path prefixed by /cygdrive for fixpath to work.
49666 new_path="$CYGWIN_ROOT_PATH$input_path"
49667 fi
49668 fi
49669
49670
49671 if test "x$path" != "x$new_path"; then
49672 MSVC_DLL="$new_path"
49673 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49674 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49675 fi
49676
49677 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49678
49679 path="$MSVC_DLL"
49680 has_colon=`$ECHO $path | $GREP ^.:`
49681 new_path="$path"
49682 if test "x$has_colon" = x; then
49683 # Not in mixed or Windows style, start by that.
49684 new_path=`cmd //c echo $path`
49685 fi
49686
49687
49688 input_path="$new_path"
49689 # Check if we need to convert this using DOS-style short mode. If the path
49690 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49691 # take no chances and rewrite it.
49692 # Note: m4 eats our [], so we need to use [ and ] instead.
49693 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
49694 if test "x$has_forbidden_chars" != x; then
49695 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49696 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49697 fi
49698
49699
49700 windows_path="$new_path"
49701 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49702 unix_path=`$CYGPATH -u "$windows_path"`
49703 new_path="$unix_path"
49704 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49705 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49706 new_path="$unix_path"
49707 fi
49708
49709 if test "x$path" != "x$new_path"; then
49710 MSVC_DLL="$new_path"
49711 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49712 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49713 fi
49714
49715 # Save the first 10 bytes of this path to the storage, so fixpath can work.
49716 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
49717
49718 else
49719 # We're on a posix platform. Hooray! :)
49720 path="$MSVC_DLL"
49721 has_space=`$ECHO "$path" | $GREP " "`
49722 if test "x$has_space" != x; then
49723 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49724 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49725 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
49726 fi
49727
49728 # Use eval to expand a potential ~
49729 eval path="$path"
49730 if test ! -f "$path" && test ! -d "$path"; then
49731 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
49732 fi
49733
49734 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
49735 fi
49736
49737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49738 $as_echo_n "checking for $DLL_NAME... " >&6; }
49739 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49740 $as_echo "$MSVC_DLL" >&6; }
49741 else
49742 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49743 $as_echo "incorrect, ignoring" >&6; }
49744 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49745 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49746 fi
49747 fi
49748
49749 if test "x$MSVC_DLL" = x; then
49750 as_fn_error $? "Could not find a proper $MSVCP_NAME as specified by devkit" "$LINENO" 5
49751 fi
49752 MSVCP_DLL="$MSVC_DLL"
49753 else
49754
49755 DLL_NAME="${MSVCP_NAME}"
49756 MSVC_DLL=
49757
49758 if test "x$MSVC_DLL" = x; then
49759 # Probe: Using well-known location from Visual Studio 10.0
49760 if test "x$VCINSTALLDIR" != x; then
49761 CYGWIN_VC_INSTALL_DIR="$VCINSTALLDIR"
49762
49763 windows_path="$CYGWIN_VC_INSTALL_DIR"
49764 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49765 unix_path=`$CYGPATH -u "$windows_path"`
49766 CYGWIN_VC_INSTALL_DIR="$unix_path"
49767 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49768 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49769 CYGWIN_VC_INSTALL_DIR="$unix_path"
49770 fi
49771
49772 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
49773 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x64/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
49774 else
49775 POSSIBLE_MSVC_DLL="$CYGWIN_VC_INSTALL_DIR/redist/x86/Microsoft.VC${VS_VERSION_INTERNAL}.CRT/$DLL_NAME"
49776 fi
49777 $ECHO "POSSIBLE_MSVC_DLL $POSSIBLEMSVC_DLL"
49778
49789 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49790 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49791 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49792 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49793 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49794 CORRECT_MSVCR_ARCH="PE32 executable"
49795 else
49796 CORRECT_MSVCR_ARCH="PE32+ executable"
49797 fi
49798 else
49799 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49800 CORRECT_MSVCR_ARCH=386
49801 else
49802 CORRECT_MSVCR_ARCH=x86-64
49803 fi
49804 fi
49805 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49806 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49807 $as_echo "ok" >&6; }
49808 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49809
49810 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49811
49812 # Input might be given as Windows format, start by converting to
49813 # unix format.
49814 path="$MSVC_DLL"
49815 new_path=`$CYGPATH -u "$path"`
49816
49817 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49818 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49819 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49820 # "foo.exe" is OK but "foo" is an error.
49821 #
49822 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49823 # It is also a way to make sure we got the proper file name for the real test later on.
49824 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49825 if test "x$test_shortpath" = x; then
49826 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49827 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49828 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
49829 fi
49830
49831 # Call helper function which possibly converts this using DOS-style short mode.
49832 # If so, the updated path is stored in $new_path.
49833
49834 input_path="$new_path"
49835 # Check if we need to convert this using DOS-style short mode. If the path
49836 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49837 # take no chances and rewrite it.
49838 # Note: m4 eats our [], so we need to use [ and ] instead.
49839 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
49840 if test "x$has_forbidden_chars" != x; then
49841 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49842 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
49843 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
49844 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
49845 # Going to short mode and back again did indeed matter. Since short mode is
49846 # case insensitive, let's make it lowercase to improve readability.
49847 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49848 # Now convert it back to Unix-style (cygpath)
49849 input_path=`$CYGPATH -u "$shortmode_path"`
49850 new_path="$input_path"
49851 fi
49852 fi
49853
49854 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
49855 if test "x$test_cygdrive_prefix" = x; then
49856 # As a simple fix, exclude /usr/bin since it's not a real path.
49857 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
49858 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
49859 # a path prefixed by /cygdrive for fixpath to work.
49860 new_path="$CYGWIN_ROOT_PATH$input_path"
49861 fi
49862 fi
49863
49864
49865 if test "x$path" != "x$new_path"; then
49866 MSVC_DLL="$new_path"
49867 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49868 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49869 fi
49870
49871 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49872
49873 path="$MSVC_DLL"
49874 has_colon=`$ECHO $path | $GREP ^.:`
49875 new_path="$path"
49876 if test "x$has_colon" = x; then
49877 # Not in mixed or Windows style, start by that.
49878 new_path=`cmd //c echo $path`
49879 fi
49880
49881
49882 input_path="$new_path"
49883 # Check if we need to convert this using DOS-style short mode. If the path
49884 # contains just simple characters, use it. Otherwise (spaces, weird characters),
49885 # take no chances and rewrite it.
49886 # Note: m4 eats our [], so we need to use [ and ] instead.
49887 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
49888 if test "x$has_forbidden_chars" != x; then
49889 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
49890 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
49891 fi
49892
49893
49894 windows_path="$new_path"
49895 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49896 unix_path=`$CYGPATH -u "$windows_path"`
49897 new_path="$unix_path"
49898 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49899 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49900 new_path="$unix_path"
49901 fi
49902
49903 if test "x$path" != "x$new_path"; then
49904 MSVC_DLL="$new_path"
49905 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
49906 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
49907 fi
49908
49909 # Save the first 10 bytes of this path to the storage, so fixpath can work.
49910 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
49911
49912 else
49913 # We're on a posix platform. Hooray! :)
49914 path="$MSVC_DLL"
49915 has_space=`$ECHO "$path" | $GREP " "`
49916 if test "x$has_space" != x; then
49917 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49918 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49919 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
49920 fi
49921
49922 # Use eval to expand a potential ~
49923 eval path="$path"
49924 if test ! -f "$path" && test ! -d "$path"; then
49925 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
49926 fi
49927
49928 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
49929 fi
49930
49931 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
49932 $as_echo_n "checking for $DLL_NAME... " >&6; }
49933 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
49934 $as_echo "$MSVC_DLL" >&6; }
49935 else
49936 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
49937 $as_echo "incorrect, ignoring" >&6; }
49938 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
49939 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
49940 fi
49941 fi
49942
49943 fi
49944 fi
49945
49946 if test "x$MSVC_DLL" = x; then
49947 # Probe: Check in the Boot JDK directory.
49948 POSSIBLE_MSVC_DLL="$BOOT_JDK/bin/$DLL_NAME"
49949
49950 DLL_NAME="$DLL_NAME"
49960 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
49961 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49962 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
49963 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
49964 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49965 CORRECT_MSVCR_ARCH="PE32 executable"
49966 else
49967 CORRECT_MSVCR_ARCH="PE32+ executable"
49968 fi
49969 else
49970 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
49971 CORRECT_MSVCR_ARCH=386
49972 else
49973 CORRECT_MSVCR_ARCH=x86-64
49974 fi
49975 fi
49976 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
49977 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
49978 $as_echo "ok" >&6; }
49979 MSVC_DLL="$POSSIBLE_MSVC_DLL"
49980
49981 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49982
49983 # Input might be given as Windows format, start by converting to
49984 # unix format.
49985 path="$MSVC_DLL"
49986 new_path=`$CYGPATH -u "$path"`
49987
49988 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
49989 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
49990 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
49991 # "foo.exe" is OK but "foo" is an error.
49992 #
49993 # This test is therefore slightly more accurate than "test -f" to check for file precense.
49994 # It is also a way to make sure we got the proper file name for the real test later on.
49995 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
49996 if test "x$test_shortpath" = x; then
49997 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
49998 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
49999 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
50000 fi
50001
50002 # Call helper function which possibly converts this using DOS-style short mode.
50003 # If so, the updated path is stored in $new_path.
50004
50005 input_path="$new_path"
50006 # Check if we need to convert this using DOS-style short mode. If the path
50007 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50008 # take no chances and rewrite it.
50009 # Note: m4 eats our [], so we need to use [ and ] instead.
50010 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
50011 if test "x$has_forbidden_chars" != x; then
50012 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50013 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
50014 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
50015 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
50016 # Going to short mode and back again did indeed matter. Since short mode is
50017 # case insensitive, let's make it lowercase to improve readability.
50018 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50019 # Now convert it back to Unix-style (cygpath)
50020 input_path=`$CYGPATH -u "$shortmode_path"`
50021 new_path="$input_path"
50022 fi
50023 fi
50024
50025 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
50026 if test "x$test_cygdrive_prefix" = x; then
50027 # As a simple fix, exclude /usr/bin since it's not a real path.
50028 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
50029 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
50030 # a path prefixed by /cygdrive for fixpath to work.
50031 new_path="$CYGWIN_ROOT_PATH$input_path"
50032 fi
50033 fi
50034
50035
50036 if test "x$path" != "x$new_path"; then
50037 MSVC_DLL="$new_path"
50038 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50039 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50040 fi
50041
50042 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50043
50044 path="$MSVC_DLL"
50045 has_colon=`$ECHO $path | $GREP ^.:`
50046 new_path="$path"
50047 if test "x$has_colon" = x; then
50048 # Not in mixed or Windows style, start by that.
50049 new_path=`cmd //c echo $path`
50050 fi
50051
50052
50053 input_path="$new_path"
50054 # Check if we need to convert this using DOS-style short mode. If the path
50055 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50056 # take no chances and rewrite it.
50057 # Note: m4 eats our [], so we need to use [ and ] instead.
50058 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
50059 if test "x$has_forbidden_chars" != x; then
50060 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50061 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50062 fi
50063
50064
50065 windows_path="$new_path"
50066 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50067 unix_path=`$CYGPATH -u "$windows_path"`
50068 new_path="$unix_path"
50069 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50070 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50071 new_path="$unix_path"
50072 fi
50073
50074 if test "x$path" != "x$new_path"; then
50075 MSVC_DLL="$new_path"
50076 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50077 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50078 fi
50079
50080 # Save the first 10 bytes of this path to the storage, so fixpath can work.
50081 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
50082
50083 else
50084 # We're on a posix platform. Hooray! :)
50085 path="$MSVC_DLL"
50086 has_space=`$ECHO "$path" | $GREP " "`
50087 if test "x$has_space" != x; then
50088 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50089 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50090 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50091 fi
50092
50093 # Use eval to expand a potential ~
50094 eval path="$path"
50095 if test ! -f "$path" && test ! -d "$path"; then
50096 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50097 fi
50098
50099 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
50100 fi
50101
50102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50103 $as_echo_n "checking for $DLL_NAME... " >&6; }
50104 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50105 $as_echo "$MSVC_DLL" >&6; }
50106 else
50107 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50108 $as_echo "incorrect, ignoring" >&6; }
50109 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50110 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50111 fi
50112 fi
50113
50114 fi
50115
50116 if test "x$MSVC_DLL" = x; then
50117 # Probe: Look in the Windows system32 directory
50118 CYGWIN_SYSTEMROOT="$SYSTEMROOT"
50119
50120 windows_path="$CYGWIN_SYSTEMROOT"
50121 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50141 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50142 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50143 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50144 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50145 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50146 CORRECT_MSVCR_ARCH="PE32 executable"
50147 else
50148 CORRECT_MSVCR_ARCH="PE32+ executable"
50149 fi
50150 else
50151 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50152 CORRECT_MSVCR_ARCH=386
50153 else
50154 CORRECT_MSVCR_ARCH=x86-64
50155 fi
50156 fi
50157 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50158 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50159 $as_echo "ok" >&6; }
50160 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50161
50162 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50163
50164 # Input might be given as Windows format, start by converting to
50165 # unix format.
50166 path="$MSVC_DLL"
50167 new_path=`$CYGPATH -u "$path"`
50168
50169 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
50170 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
50171 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
50172 # "foo.exe" is OK but "foo" is an error.
50173 #
50174 # This test is therefore slightly more accurate than "test -f" to check for file precense.
50175 # It is also a way to make sure we got the proper file name for the real test later on.
50176 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
50177 if test "x$test_shortpath" = x; then
50178 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50179 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50180 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
50181 fi
50182
50183 # Call helper function which possibly converts this using DOS-style short mode.
50184 # If so, the updated path is stored in $new_path.
50185
50186 input_path="$new_path"
50187 # Check if we need to convert this using DOS-style short mode. If the path
50188 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50189 # take no chances and rewrite it.
50190 # Note: m4 eats our [], so we need to use [ and ] instead.
50191 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
50192 if test "x$has_forbidden_chars" != x; then
50193 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50194 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
50195 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
50196 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
50197 # Going to short mode and back again did indeed matter. Since short mode is
50198 # case insensitive, let's make it lowercase to improve readability.
50199 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50200 # Now convert it back to Unix-style (cygpath)
50201 input_path=`$CYGPATH -u "$shortmode_path"`
50202 new_path="$input_path"
50203 fi
50204 fi
50205
50206 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
50207 if test "x$test_cygdrive_prefix" = x; then
50208 # As a simple fix, exclude /usr/bin since it's not a real path.
50209 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
50210 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
50211 # a path prefixed by /cygdrive for fixpath to work.
50212 new_path="$CYGWIN_ROOT_PATH$input_path"
50213 fi
50214 fi
50215
50216
50217 if test "x$path" != "x$new_path"; then
50218 MSVC_DLL="$new_path"
50219 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50220 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50221 fi
50222
50223 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50224
50225 path="$MSVC_DLL"
50226 has_colon=`$ECHO $path | $GREP ^.:`
50227 new_path="$path"
50228 if test "x$has_colon" = x; then
50229 # Not in mixed or Windows style, start by that.
50230 new_path=`cmd //c echo $path`
50231 fi
50232
50233
50234 input_path="$new_path"
50235 # Check if we need to convert this using DOS-style short mode. If the path
50236 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50237 # take no chances and rewrite it.
50238 # Note: m4 eats our [], so we need to use [ and ] instead.
50239 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
50240 if test "x$has_forbidden_chars" != x; then
50241 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50242 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50243 fi
50244
50245
50246 windows_path="$new_path"
50247 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50248 unix_path=`$CYGPATH -u "$windows_path"`
50249 new_path="$unix_path"
50250 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50251 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50252 new_path="$unix_path"
50253 fi
50254
50255 if test "x$path" != "x$new_path"; then
50256 MSVC_DLL="$new_path"
50257 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50258 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50259 fi
50260
50261 # Save the first 10 bytes of this path to the storage, so fixpath can work.
50262 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
50263
50264 else
50265 # We're on a posix platform. Hooray! :)
50266 path="$MSVC_DLL"
50267 has_space=`$ECHO "$path" | $GREP " "`
50268 if test "x$has_space" != x; then
50269 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50270 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50271 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50272 fi
50273
50274 # Use eval to expand a potential ~
50275 eval path="$path"
50276 if test ! -f "$path" && test ! -d "$path"; then
50277 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50278 fi
50279
50280 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
50281 fi
50282
50283 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50284 $as_echo_n "checking for $DLL_NAME... " >&6; }
50285 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50286 $as_echo "$MSVC_DLL" >&6; }
50287 else
50288 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50289 $as_echo "incorrect, ignoring" >&6; }
50290 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50291 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50292 fi
50293 fi
50294
50295 fi
50296
50297 if test "x$MSVC_DLL" = x; then
50298 # Probe: If Visual Studio Express is installed, there is usually one with the debugger
50299 if test "x$VS100COMNTOOLS" != x; then
50300 CYGWIN_VS_TOOLS_DIR="$VS100COMNTOOLS/.."
50301
50302 windows_path="$CYGWIN_VS_TOOLS_DIR"
50329 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50330 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50331 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50332 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50333 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50334 CORRECT_MSVCR_ARCH="PE32 executable"
50335 else
50336 CORRECT_MSVCR_ARCH="PE32+ executable"
50337 fi
50338 else
50339 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50340 CORRECT_MSVCR_ARCH=386
50341 else
50342 CORRECT_MSVCR_ARCH=x86-64
50343 fi
50344 fi
50345 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50346 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50347 $as_echo "ok" >&6; }
50348 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50349
50350 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50351
50352 # Input might be given as Windows format, start by converting to
50353 # unix format.
50354 path="$MSVC_DLL"
50355 new_path=`$CYGPATH -u "$path"`
50356
50357 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
50358 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
50359 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
50360 # "foo.exe" is OK but "foo" is an error.
50361 #
50362 # This test is therefore slightly more accurate than "test -f" to check for file precense.
50363 # It is also a way to make sure we got the proper file name for the real test later on.
50364 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
50365 if test "x$test_shortpath" = x; then
50366 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50367 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50368 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
50369 fi
50370
50371 # Call helper function which possibly converts this using DOS-style short mode.
50372 # If so, the updated path is stored in $new_path.
50373
50374 input_path="$new_path"
50375 # Check if we need to convert this using DOS-style short mode. If the path
50376 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50377 # take no chances and rewrite it.
50378 # Note: m4 eats our [], so we need to use [ and ] instead.
50379 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
50380 if test "x$has_forbidden_chars" != x; then
50381 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50382 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
50383 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
50384 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
50385 # Going to short mode and back again did indeed matter. Since short mode is
50386 # case insensitive, let's make it lowercase to improve readability.
50387 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50388 # Now convert it back to Unix-style (cygpath)
50389 input_path=`$CYGPATH -u "$shortmode_path"`
50390 new_path="$input_path"
50391 fi
50392 fi
50393
50394 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
50395 if test "x$test_cygdrive_prefix" = x; then
50396 # As a simple fix, exclude /usr/bin since it's not a real path.
50397 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
50398 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
50399 # a path prefixed by /cygdrive for fixpath to work.
50400 new_path="$CYGWIN_ROOT_PATH$input_path"
50401 fi
50402 fi
50403
50404
50405 if test "x$path" != "x$new_path"; then
50406 MSVC_DLL="$new_path"
50407 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50408 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50409 fi
50410
50411 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50412
50413 path="$MSVC_DLL"
50414 has_colon=`$ECHO $path | $GREP ^.:`
50415 new_path="$path"
50416 if test "x$has_colon" = x; then
50417 # Not in mixed or Windows style, start by that.
50418 new_path=`cmd //c echo $path`
50419 fi
50420
50421
50422 input_path="$new_path"
50423 # Check if we need to convert this using DOS-style short mode. If the path
50424 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50425 # take no chances and rewrite it.
50426 # Note: m4 eats our [], so we need to use [ and ] instead.
50427 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
50428 if test "x$has_forbidden_chars" != x; then
50429 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50430 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50431 fi
50432
50433
50434 windows_path="$new_path"
50435 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50436 unix_path=`$CYGPATH -u "$windows_path"`
50437 new_path="$unix_path"
50438 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50439 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50440 new_path="$unix_path"
50441 fi
50442
50443 if test "x$path" != "x$new_path"; then
50444 MSVC_DLL="$new_path"
50445 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50446 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50447 fi
50448
50449 # Save the first 10 bytes of this path to the storage, so fixpath can work.
50450 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
50451
50452 else
50453 # We're on a posix platform. Hooray! :)
50454 path="$MSVC_DLL"
50455 has_space=`$ECHO "$path" | $GREP " "`
50456 if test "x$has_space" != x; then
50457 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50458 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50459 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50460 fi
50461
50462 # Use eval to expand a potential ~
50463 eval path="$path"
50464 if test ! -f "$path" && test ! -d "$path"; then
50465 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50466 fi
50467
50468 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
50469 fi
50470
50471 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50472 $as_echo_n "checking for $DLL_NAME... " >&6; }
50473 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50474 $as_echo "$MSVC_DLL" >&6; }
50475 else
50476 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50477 $as_echo "incorrect, ignoring" >&6; }
50478 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50479 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50480 fi
50481 fi
50482
50483 fi
50484 fi
50485
50486 if test "x$MSVC_DLL" = x; then
50487 # Probe: Search wildly in the VCINSTALLDIR. We've probably lost by now.
50488 # (This was the original behaviour; kept since it might turn something up)
50489 if test "x$CYGWIN_VC_INSTALL_DIR" != x; then
50490 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
50514 MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
50515 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50516 # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
50517 # on x32 and "PE32+ executable for MS Windows (DLL) (GUI) Mono/.Net assembly" on x64 systems.
50518 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50519 CORRECT_MSVCR_ARCH="PE32 executable"
50520 else
50521 CORRECT_MSVCR_ARCH="PE32+ executable"
50522 fi
50523 else
50524 if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
50525 CORRECT_MSVCR_ARCH=386
50526 else
50527 CORRECT_MSVCR_ARCH=x86-64
50528 fi
50529 fi
50530 if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
50531 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
50532 $as_echo "ok" >&6; }
50533 MSVC_DLL="$POSSIBLE_MSVC_DLL"
50534
50535 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50536
50537 # Input might be given as Windows format, start by converting to
50538 # unix format.
50539 path="$MSVC_DLL"
50540 new_path=`$CYGPATH -u "$path"`
50541
50542 # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
50543 # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
50544 # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
50545 # "foo.exe" is OK but "foo" is an error.
50546 #
50547 # This test is therefore slightly more accurate than "test -f" to check for file precense.
50548 # It is also a way to make sure we got the proper file name for the real test later on.
50549 test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
50550 if test "x$test_shortpath" = x; then
50551 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50552 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50553 as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
50554 fi
50555
50556 # Call helper function which possibly converts this using DOS-style short mode.
50557 # If so, the updated path is stored in $new_path.
50558
50559 input_path="$new_path"
50560 # Check if we need to convert this using DOS-style short mode. If the path
50561 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50562 # take no chances and rewrite it.
50563 # Note: m4 eats our [], so we need to use [ and ] instead.
50564 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
50565 if test "x$has_forbidden_chars" != x; then
50566 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50567 shortmode_path=`$CYGPATH -s -m -a "$input_path"`
50568 path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
50569 if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
50570 # Going to short mode and back again did indeed matter. Since short mode is
50571 # case insensitive, let's make it lowercase to improve readability.
50572 shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50573 # Now convert it back to Unix-style (cygpath)
50574 input_path=`$CYGPATH -u "$shortmode_path"`
50575 new_path="$input_path"
50576 fi
50577 fi
50578
50579 test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
50580 if test "x$test_cygdrive_prefix" = x; then
50581 # As a simple fix, exclude /usr/bin since it's not a real path.
50582 if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
50583 # The path is in a Cygwin special directory (e.g. /home). We need this converted to
50584 # a path prefixed by /cygdrive for fixpath to work.
50585 new_path="$CYGWIN_ROOT_PATH$input_path"
50586 fi
50587 fi
50588
50589
50590 if test "x$path" != "x$new_path"; then
50591 MSVC_DLL="$new_path"
50592 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50593 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50594 fi
50595
50596 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50597
50598 path="$MSVC_DLL"
50599 has_colon=`$ECHO $path | $GREP ^.:`
50600 new_path="$path"
50601 if test "x$has_colon" = x; then
50602 # Not in mixed or Windows style, start by that.
50603 new_path=`cmd //c echo $path`
50604 fi
50605
50606
50607 input_path="$new_path"
50608 # Check if we need to convert this using DOS-style short mode. If the path
50609 # contains just simple characters, use it. Otherwise (spaces, weird characters),
50610 # take no chances and rewrite it.
50611 # Note: m4 eats our [], so we need to use [ and ] instead.
50612 has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
50613 if test "x$has_forbidden_chars" != x; then
50614 # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
50615 new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
50616 fi
50617
50618
50619 windows_path="$new_path"
50620 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
50621 unix_path=`$CYGPATH -u "$windows_path"`
50622 new_path="$unix_path"
50623 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
50624 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
50625 new_path="$unix_path"
50626 fi
50627
50628 if test "x$path" != "x$new_path"; then
50629 MSVC_DLL="$new_path"
50630 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
50631 $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
50632 fi
50633
50634 # Save the first 10 bytes of this path to the storage, so fixpath can work.
50635 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
50636
50637 else
50638 # We're on a posix platform. Hooray! :)
50639 path="$MSVC_DLL"
50640 has_space=`$ECHO "$path" | $GREP " "`
50641 if test "x$has_space" != x; then
50642 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
50643 $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
50644 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50645 fi
50646
50647 # Use eval to expand a potential ~
50648 eval path="$path"
50649 if test ! -f "$path" && test ! -d "$path"; then
50650 as_fn_error $? "The path of MSVC_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50651 fi
50652
50653 MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
50654 fi
50655
50656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50657 $as_echo_n "checking for $DLL_NAME... " >&6; }
50658 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
50659 $as_echo "$MSVC_DLL" >&6; }
50660 else
50661 { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
50662 $as_echo "incorrect, ignoring" >&6; }
50663 { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
50664 $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
50665 fi
50666 fi
50667
50668 fi
50669 fi
50670
50671 if test "x$MSVC_DLL" = x; then
50672 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
50673 $as_echo_n "checking for $DLL_NAME... " >&6; }
50674 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
50675 $as_echo "no" >&6; }
50676 as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
50677 fi
50678
50679 MSVCP_DLL="$MSVC_DLL"
50680 fi
50681
50682 fi
50683
50684
50685
50686 # Check whether --with-dxsdk was given.
50687 if test "${with_dxsdk+set}" = set; then :
50688 withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
50689 $as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
50690 fi
50691
50692
50693
50694
50695 # Check whether --with-dxsdk-lib was given.
50696 if test "${with_dxsdk_lib+set}" = set; then :
50697 withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
50698 $as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
50699 fi
50700
50701
|