890 JVM_VARIANT_CORE
891 JVM_VARIANT_ZEROSHARK
892 JVM_VARIANT_ZERO
893 JVM_VARIANT_KERNEL
894 JVM_VARIANT_MINIMAL1
895 JVM_VARIANT_CLIENT
896 JVM_VARIANT_SERVER
897 JVM_VARIANTS
898 JVM_INTERPRETER
899 JDK_VARIANT
900 SET_OPENJDK
901 BUILD_LOG_WRAPPER
902 BUILD_LOG_PREVIOUS
903 BUILD_LOG
904 TOPDIR
905 PATH_SEP
906 ZERO_ARCHDEF
907 DEFINE_CROSS_COMPILE_ARCH
908 LP64
909 OPENJDK_TARGET_OS_EXPORT_DIR
910 OPENJDK_TARGET_OS_API_DIR
911 OPENJDK_TARGET_CPU_JLI_CFLAGS
912 OPENJDK_TARGET_CPU_OSARCH
913 OPENJDK_TARGET_CPU_ISADIR
914 OPENJDK_TARGET_CPU_LIBDIR
915 OPENJDK_TARGET_CPU_LEGACY_LIB
916 OPENJDK_TARGET_CPU_LEGACY
917 REQUIRED_OS_VERSION
918 REQUIRED_OS_NAME
919 COMPILE_TYPE
920 OPENJDK_TARGET_CPU_ENDIAN
921 OPENJDK_TARGET_CPU_BITS
922 OPENJDK_TARGET_CPU_ARCH
923 OPENJDK_TARGET_CPU
924 OPENJDK_TARGET_OS_ENV
925 OPENJDK_TARGET_OS_API
926 OPENJDK_TARGET_OS
927 OPENJDK_BUILD_CPU_ENDIAN
928 OPENJDK_BUILD_CPU_BITS
929 OPENJDK_BUILD_CPU_ARCH
930 OPENJDK_BUILD_CPU
931 OPENJDK_BUILD_OS_ENV
932 OPENJDK_BUILD_OS_API
933 OPENJDK_BUILD_OS
934 OPENJDK_BUILD_AUTOCONF_NAME
935 OPENJDK_TARGET_AUTOCONF_NAME
936 target_os
937 target_vendor
938 target_cpu
939 target
940 host_os
941 host_vendor
942 host_cpu
943 host
944 build_os
945 build_vendor
946 build_cpu
947 build
948 CPIO
949 SETFILE
950 DF
951 READLINK
952 CYGPATH
3394 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3395 #
3396 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3397 # or visit www.oracle.com if you need additional information or have any
3398 # questions.
3399 #
3400
3401 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3402 # If so, then append $1 to $2 \
3403 # Also set JVM_ARG_OK to true/false depending on outcome.
3404
3405
3406 # Appends a string to a path variable, only adding the : when needed.
3407
3408
3409 # Prepends a string to a path variable, only adding the : when needed.
3410
3411
3412 # This will make sure the given variable points to a full and proper
3413 # path. This means:
3414 # 1) There will be no spaces in the path. On posix platforms,
3415 # spaces in the path will result in an error. On Windows,
3416 # the path will be rewritten using short-style to be space-free.
3417 # 2) The path will be absolute, and it will be in unix-style (on
3418 # cygwin).
3419 # $1: The name of the variable to fix
3420
3421
3422 # This will make sure the given variable points to a executable
3423 # with a full and proper path. This means:
3424 # 1) There will be no spaces in the path. On posix platforms,
3425 # spaces in the path will result in an error. On Windows,
3426 # the path will be rewritten using short-style to be space-free.
3427 # 2) The path will be absolute, and it will be in unix-style (on
3428 # cygwin).
3429 # Any arguments given to the executable is preserved.
3430 # If the input variable does not have a directory specification, then
3431 # it need to be in the PATH.
3432 # $1: The name of the variable to fix
3433
3434
3435
3436
3437 # Register a --with argument but mark it as deprecated
3438 # $1: The name of the with argument to deprecate, not including --with-
3439
3440
3441 # Register a --enable argument but mark it as deprecated
3442 # $1: The name of the with argument to deprecate, not including --enable-
3443 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3444
4310 # Check if the VS env variables were setup prior to running configure.
4311 # If not, then find vcvarsall.bat and run it automatically, and integrate
4312 # the set env variables into the spec file.
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323
4324 # This line needs to be here, verbatim, after all includes and the dummy hook
4325 # definitions. It is replaced with custom functionality when building
4326 # custom sources.
4327 #CUSTOM_AUTOCONF_INCLUDE
4328
4329 # Do not change or remove the following line, it is needed for consistency checks:
4330 DATE_WHEN_GENERATED=1410791401
4331
4332 ###############################################################################
4333 #
4334 # Initialization / Boot-strapping
4335 #
4336 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4337 # thus it jumps back and forth, each time gaining something needed later on.
4338 #
4339 ###############################################################################
4340
4341 # If we are requested to print additional help, do that and then exit.
4342 # This must be the very first call.
4343
4344 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4345 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4346 $PRINTF "Which are valid to use depends on the build platform.\n"
4347 for toolchain in $VALID_TOOLCHAINS_all; do
4348 # Use indirect variable referencing
4349 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4350 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
13507 # to use the configure naming style.
13508
13509
13510
13511
13512
13513 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13514 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13515 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13516 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13517 OPENJDK_TARGET_AUTOCONF_NAME="$host"
13518 OPENJDK_BUILD_AUTOCONF_NAME="$build"
13519
13520
13521
13522 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13523
13524 case "$build_os" in
13525 *linux*)
13526 VAR_OS=linux
13527 VAR_OS_API=posix
13528 VAR_OS_ENV=linux
13529 ;;
13530 *solaris*)
13531 VAR_OS=solaris
13532 VAR_OS_API=posix
13533 VAR_OS_ENV=solaris
13534 ;;
13535 *darwin*)
13536 VAR_OS=macosx
13537 VAR_OS_API=posix
13538 VAR_OS_ENV=macosx
13539 ;;
13540 *bsd*)
13541 VAR_OS=bsd
13542 VAR_OS_API=posix
13543 VAR_OS_ENV=bsd
13544 ;;
13545 *cygwin*)
13546 VAR_OS=windows
13547 VAR_OS_API=winapi
13548 VAR_OS_ENV=windows.cygwin
13549 ;;
13550 *mingw*)
13551 VAR_OS=windows
13552 VAR_OS_API=winapi
13553 VAR_OS_ENV=windows.msys
13554 ;;
13555 *aix*)
13556 VAR_OS=aix
13557 VAR_OS_API=posix
13558 VAR_OS_ENV=aix
13559 ;;
13560 *)
13561 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13562 ;;
13563 esac
13564
13565
13566 # First argument is the cpu name from the trip/quad
13567 case "$build_cpu" in
13568 x86_64)
13569 VAR_CPU=x86_64
13570 VAR_CPU_ARCH=x86
13571 VAR_CPU_BITS=64
13572 VAR_CPU_ENDIAN=little
13573 ;;
13574 i?86)
13575 VAR_CPU=x86
13576 VAR_CPU_ARCH=x86
13577 VAR_CPU_BITS=32
13578 VAR_CPU_ENDIAN=little
13615 ;;
13616 sparc)
13617 VAR_CPU=sparc
13618 VAR_CPU_ARCH=sparc
13619 VAR_CPU_BITS=32
13620 VAR_CPU_ENDIAN=big
13621 ;;
13622 sparcv9|sparc64)
13623 VAR_CPU=sparcv9
13624 VAR_CPU_ARCH=sparc
13625 VAR_CPU_BITS=64
13626 VAR_CPU_ENDIAN=big
13627 ;;
13628 *)
13629 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13630 ;;
13631 esac
13632
13633 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13634 OPENJDK_BUILD_OS="$VAR_OS"
13635 OPENJDK_BUILD_OS_API="$VAR_OS_API"
13636 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13637 OPENJDK_BUILD_CPU="$VAR_CPU"
13638 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13639 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13640 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13641
13642
13643
13644
13645
13646
13647
13648
13649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13650 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13651 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13652 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13653
13654 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13655
13656 case "$host_os" in
13657 *linux*)
13658 VAR_OS=linux
13659 VAR_OS_API=posix
13660 VAR_OS_ENV=linux
13661 ;;
13662 *solaris*)
13663 VAR_OS=solaris
13664 VAR_OS_API=posix
13665 VAR_OS_ENV=solaris
13666 ;;
13667 *darwin*)
13668 VAR_OS=macosx
13669 VAR_OS_API=posix
13670 VAR_OS_ENV=macosx
13671 ;;
13672 *bsd*)
13673 VAR_OS=bsd
13674 VAR_OS_API=posix
13675 VAR_OS_ENV=bsd
13676 ;;
13677 *cygwin*)
13678 VAR_OS=windows
13679 VAR_OS_API=winapi
13680 VAR_OS_ENV=windows.cygwin
13681 ;;
13682 *mingw*)
13683 VAR_OS=windows
13684 VAR_OS_API=winapi
13685 VAR_OS_ENV=windows.msys
13686 ;;
13687 *aix*)
13688 VAR_OS=aix
13689 VAR_OS_API=posix
13690 VAR_OS_ENV=aix
13691 ;;
13692 *)
13693 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13694 ;;
13695 esac
13696
13697
13698 # First argument is the cpu name from the trip/quad
13699 case "$host_cpu" in
13700 x86_64)
13701 VAR_CPU=x86_64
13702 VAR_CPU_ARCH=x86
13703 VAR_CPU_BITS=64
13704 VAR_CPU_ENDIAN=little
13705 ;;
13706 i?86)
13707 VAR_CPU=x86
13708 VAR_CPU_ARCH=x86
13709 VAR_CPU_BITS=32
13710 VAR_CPU_ENDIAN=little
13747 ;;
13748 sparc)
13749 VAR_CPU=sparc
13750 VAR_CPU_ARCH=sparc
13751 VAR_CPU_BITS=32
13752 VAR_CPU_ENDIAN=big
13753 ;;
13754 sparcv9|sparc64)
13755 VAR_CPU=sparcv9
13756 VAR_CPU_ARCH=sparc
13757 VAR_CPU_BITS=64
13758 VAR_CPU_ENDIAN=big
13759 ;;
13760 *)
13761 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13762 ;;
13763 esac
13764
13765 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13766 OPENJDK_TARGET_OS="$VAR_OS"
13767 OPENJDK_TARGET_OS_API="$VAR_OS_API"
13768 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13769 OPENJDK_TARGET_CPU="$VAR_CPU"
13770 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13771 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13772 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13773
13774
13775
13776
13777
13778
13779
13780
13781 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13782 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13783 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13784 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13785
13786
13787
13788 # Check whether --with-target-bits was given.
13916
13917
13918 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13919 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13920 OPENJDK_TARGET_CPU_JLI="i386"
13921 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13922 # On all platforms except macosx, we replace x86_64 with amd64.
13923 OPENJDK_TARGET_CPU_JLI="amd64"
13924 fi
13925 # Now setup the -D flags for building libjli.
13926 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13927 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13928 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13929 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13930 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13931 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13932 fi
13933 fi
13934
13935
13936 # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
13937 if test "x$OPENJDK_TARGET_OS_API" = xposix; then
13938 OPENJDK_TARGET_OS_API_DIR="unix"
13939 fi
13940 if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
13941 OPENJDK_TARGET_OS_API_DIR="windows"
13942 fi
13943
13944
13945 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13946 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13947 else
13948 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
13949 fi
13950
13951
13952 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13953 A_LP64="LP64:="
13954 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13955 # unpack200.exe
13956 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13957 ADD_LP64="-D_LP64=1"
13958 fi
13959 fi
13960 LP64=$A_LP64
13961
13962
13963 if test "x$COMPILE_TYPE" = "xcross"; then
13964 # FIXME: ... or should this include reduced builds..?
13965 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13966 else
13967 DEFINE_CROSS_COMPILE_ARCH=""
13968 fi
14178
14179 windows_path="$new_path"
14180 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14181 unix_path=`$CYGPATH -u "$windows_path"`
14182 new_path="$unix_path"
14183 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14184 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14185 new_path="$unix_path"
14186 fi
14187
14188 if test "x$path" != "x$new_path"; then
14189 CURDIR="$new_path"
14190 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14191 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14192 fi
14193
14194 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14195 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14196
14197 else
14198 # We're on a posix platform. Hooray! :)
14199 path="$CURDIR"
14200 has_space=`$ECHO "$path" | $GREP " "`
14201 if test "x$has_space" != x; then
14202 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14203 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14204 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14205 fi
14206
14207 # Use eval to expand a potential ~
14208 eval path="$path"
14209 if test ! -f "$path" && test ! -d "$path"; then
14210 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14211 fi
14212
14213 CURDIR="`cd "$path"; $THEPWDCMD -L`"
14214 fi
14215
14216
14217 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14218
14300
14301 windows_path="$new_path"
14302 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14303 unix_path=`$CYGPATH -u "$windows_path"`
14304 new_path="$unix_path"
14305 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14306 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14307 new_path="$unix_path"
14308 fi
14309
14310 if test "x$path" != "x$new_path"; then
14311 TOPDIR="$new_path"
14312 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14313 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14314 fi
14315
14316 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14317 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14318
14319 else
14320 # We're on a posix platform. Hooray! :)
14321 path="$TOPDIR"
14322 has_space=`$ECHO "$path" | $GREP " "`
14323 if test "x$has_space" != x; then
14324 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14325 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14326 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14327 fi
14328
14329 # Use eval to expand a potential ~
14330 eval path="$path"
14331 if test ! -f "$path" && test ! -d "$path"; then
14332 as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14333 fi
14334
14335 TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14336 fi
14337
14338 # SRC_ROOT is a traditional alias for TOPDIR.
14339 SRC_ROOT=$TOPDIR
14340
14820
14821 windows_path="$new_path"
14822 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14823 unix_path=`$CYGPATH -u "$windows_path"`
14824 new_path="$unix_path"
14825 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14826 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14827 new_path="$unix_path"
14828 fi
14829
14830 if test "x$path" != "x$new_path"; then
14831 with_devkit="$new_path"
14832 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14833 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14834 fi
14835
14836 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14837 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14838
14839 else
14840 # We're on a posix platform. Hooray! :)
14841 path="$with_devkit"
14842 has_space=`$ECHO "$path" | $GREP " "`
14843 if test "x$has_space" != x; then
14844 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14845 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14846 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14847 fi
14848
14849 # Use eval to expand a potential ~
14850 eval path="$path"
14851 if test ! -f "$path" && test ! -d "$path"; then
14852 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14853 fi
14854
14855 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14856 fi
14857
14858 DEVKIT_ROOT="$with_devkit"
14859 # Check for a meta data info file in the root of the devkit
14860 if test -f "$DEVKIT_ROOT/devkit.info"; then
15294
15295 windows_path="$new_path"
15296 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15297 unix_path=`$CYGPATH -u "$windows_path"`
15298 new_path="$unix_path"
15299 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15300 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15301 new_path="$unix_path"
15302 fi
15303
15304 if test "x$path" != "x$new_path"; then
15305 OUTPUT_ROOT="$new_path"
15306 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15307 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15308 fi
15309
15310 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15311 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15312
15313 else
15314 # We're on a posix platform. Hooray! :)
15315 path="$OUTPUT_ROOT"
15316 has_space=`$ECHO "$path" | $GREP " "`
15317 if test "x$has_space" != x; then
15318 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15319 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15320 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15321 fi
15322
15323 # Use eval to expand a potential ~
15324 eval path="$path"
15325 if test ! -f "$path" && test ! -d "$path"; then
15326 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15327 fi
15328
15329 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15330 fi
15331
15332
15333 SPEC=$OUTPUT_ROOT/spec.gmk
15334
15667
15668 # Output is in $new_path
15669
15670 windows_path="$new_path"
15671 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15672 unix_path=`$CYGPATH -u "$windows_path"`
15673 new_path="$unix_path"
15674 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15675 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15676 new_path="$unix_path"
15677 fi
15678
15679 # remove trailing .exe if any
15680 new_path="${new_path/%.exe/}"
15681
15682 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15683 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15684 fi
15685
15686 else
15687 # We're on a posix platform. Hooray! :)
15688 # First separate the path from the arguments. This will split at the first
15689 # space.
15690 complete="$FOUND_MAKE"
15691 path="${complete%% *}"
15692 tmp="$complete EOL"
15693 arguments="${tmp#* }"
15694
15695 # Cannot rely on the command "which" here since it doesn't always work.
15696 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15697 if test -z "$is_absolute_path"; then
15698 # Path to executable is not absolute. Find it.
15699 IFS_save="$IFS"
15700 IFS=:
15701 for p in $PATH; do
15702 if test -f "$p/$path" && test -x "$p/$path"; then
15703 new_path="$p/$path"
15704 break
15705 fi
15706 done
15707 IFS="$IFS_save"
16040
16041 # Output is in $new_path
16042
16043 windows_path="$new_path"
16044 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16045 unix_path=`$CYGPATH -u "$windows_path"`
16046 new_path="$unix_path"
16047 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16048 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16049 new_path="$unix_path"
16050 fi
16051
16052 # remove trailing .exe if any
16053 new_path="${new_path/%.exe/}"
16054
16055 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16056 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16057 fi
16058
16059 else
16060 # We're on a posix platform. Hooray! :)
16061 # First separate the path from the arguments. This will split at the first
16062 # space.
16063 complete="$FOUND_MAKE"
16064 path="${complete%% *}"
16065 tmp="$complete EOL"
16066 arguments="${tmp#* }"
16067
16068 # Cannot rely on the command "which" here since it doesn't always work.
16069 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16070 if test -z "$is_absolute_path"; then
16071 # Path to executable is not absolute. Find it.
16072 IFS_save="$IFS"
16073 IFS=:
16074 for p in $PATH; do
16075 if test -f "$p/$path" && test -x "$p/$path"; then
16076 new_path="$p/$path"
16077 break
16078 fi
16079 done
16080 IFS="$IFS_save"
16410
16411 # Output is in $new_path
16412
16413 windows_path="$new_path"
16414 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16415 unix_path=`$CYGPATH -u "$windows_path"`
16416 new_path="$unix_path"
16417 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16418 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16419 new_path="$unix_path"
16420 fi
16421
16422 # remove trailing .exe if any
16423 new_path="${new_path/%.exe/}"
16424
16425 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16426 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16427 fi
16428
16429 else
16430 # We're on a posix platform. Hooray! :)
16431 # First separate the path from the arguments. This will split at the first
16432 # space.
16433 complete="$FOUND_MAKE"
16434 path="${complete%% *}"
16435 tmp="$complete EOL"
16436 arguments="${tmp#* }"
16437
16438 # Cannot rely on the command "which" here since it doesn't always work.
16439 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16440 if test -z "$is_absolute_path"; then
16441 # Path to executable is not absolute. Find it.
16442 IFS_save="$IFS"
16443 IFS=:
16444 for p in $PATH; do
16445 if test -f "$p/$path" && test -x "$p/$path"; then
16446 new_path="$p/$path"
16447 break
16448 fi
16449 done
16450 IFS="$IFS_save"
16785
16786 # Output is in $new_path
16787
16788 windows_path="$new_path"
16789 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16790 unix_path=`$CYGPATH -u "$windows_path"`
16791 new_path="$unix_path"
16792 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16793 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16794 new_path="$unix_path"
16795 fi
16796
16797 # remove trailing .exe if any
16798 new_path="${new_path/%.exe/}"
16799
16800 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16801 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16802 fi
16803
16804 else
16805 # We're on a posix platform. Hooray! :)
16806 # First separate the path from the arguments. This will split at the first
16807 # space.
16808 complete="$FOUND_MAKE"
16809 path="${complete%% *}"
16810 tmp="$complete EOL"
16811 arguments="${tmp#* }"
16812
16813 # Cannot rely on the command "which" here since it doesn't always work.
16814 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16815 if test -z "$is_absolute_path"; then
16816 # Path to executable is not absolute. Find it.
16817 IFS_save="$IFS"
16818 IFS=:
16819 for p in $PATH; do
16820 if test -f "$p/$path" && test -x "$p/$path"; then
16821 new_path="$p/$path"
16822 break
16823 fi
16824 done
16825 IFS="$IFS_save"
17154
17155 # Output is in $new_path
17156
17157 windows_path="$new_path"
17158 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17159 unix_path=`$CYGPATH -u "$windows_path"`
17160 new_path="$unix_path"
17161 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17162 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17163 new_path="$unix_path"
17164 fi
17165
17166 # remove trailing .exe if any
17167 new_path="${new_path/%.exe/}"
17168
17169 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17170 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17171 fi
17172
17173 else
17174 # We're on a posix platform. Hooray! :)
17175 # First separate the path from the arguments. This will split at the first
17176 # space.
17177 complete="$FOUND_MAKE"
17178 path="${complete%% *}"
17179 tmp="$complete EOL"
17180 arguments="${tmp#* }"
17181
17182 # Cannot rely on the command "which" here since it doesn't always work.
17183 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17184 if test -z "$is_absolute_path"; then
17185 # Path to executable is not absolute. Find it.
17186 IFS_save="$IFS"
17187 IFS=:
17188 for p in $PATH; do
17189 if test -f "$p/$path" && test -x "$p/$path"; then
17190 new_path="$p/$path"
17191 break
17192 fi
17193 done
17194 IFS="$IFS_save"
20309
20310 windows_path="$new_path"
20311 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20312 unix_path=`$CYGPATH -u "$windows_path"`
20313 new_path="$unix_path"
20314 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20315 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20316 new_path="$unix_path"
20317 fi
20318
20319 if test "x$path" != "x$new_path"; then
20320 BOOT_JDK="$new_path"
20321 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20322 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20323 fi
20324
20325 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20326 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20327
20328 else
20329 # We're on a posix platform. Hooray! :)
20330 path="$BOOT_JDK"
20331 has_space=`$ECHO "$path" | $GREP " "`
20332 if test "x$has_space" != x; then
20333 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20334 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20335 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20336 fi
20337
20338 # Use eval to expand a potential ~
20339 eval path="$path"
20340 if test ! -f "$path" && test ! -d "$path"; then
20341 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20342 fi
20343
20344 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20345 fi
20346
20347 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20348 $as_echo_n "checking for Boot JDK... " >&6; }
20349 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20641
20642 windows_path="$new_path"
20643 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20644 unix_path=`$CYGPATH -u "$windows_path"`
20645 new_path="$unix_path"
20646 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20647 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20648 new_path="$unix_path"
20649 fi
20650
20651 if test "x$path" != "x$new_path"; then
20652 BOOT_JDK="$new_path"
20653 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20654 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20655 fi
20656
20657 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20658 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20659
20660 else
20661 # We're on a posix platform. Hooray! :)
20662 path="$BOOT_JDK"
20663 has_space=`$ECHO "$path" | $GREP " "`
20664 if test "x$has_space" != x; then
20665 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20666 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20667 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20668 fi
20669
20670 # Use eval to expand a potential ~
20671 eval path="$path"
20672 if test ! -f "$path" && test ! -d "$path"; then
20673 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20674 fi
20675
20676 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20677 fi
20678
20679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20680 $as_echo_n "checking for Boot JDK... " >&6; }
20681 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20835
20836 windows_path="$new_path"
20837 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20838 unix_path=`$CYGPATH -u "$windows_path"`
20839 new_path="$unix_path"
20840 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20841 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20842 new_path="$unix_path"
20843 fi
20844
20845 if test "x$path" != "x$new_path"; then
20846 BOOT_JDK="$new_path"
20847 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20848 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20849 fi
20850
20851 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20852 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20853
20854 else
20855 # We're on a posix platform. Hooray! :)
20856 path="$BOOT_JDK"
20857 has_space=`$ECHO "$path" | $GREP " "`
20858 if test "x$has_space" != x; then
20859 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20860 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20861 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20862 fi
20863
20864 # Use eval to expand a potential ~
20865 eval path="$path"
20866 if test ! -f "$path" && test ! -d "$path"; then
20867 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20868 fi
20869
20870 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20871 fi
20872
20873 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20874 $as_echo_n "checking for Boot JDK... " >&6; }
20875 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21022
21023 windows_path="$new_path"
21024 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21025 unix_path=`$CYGPATH -u "$windows_path"`
21026 new_path="$unix_path"
21027 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21028 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21029 new_path="$unix_path"
21030 fi
21031
21032 if test "x$path" != "x$new_path"; then
21033 BOOT_JDK="$new_path"
21034 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21035 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21036 fi
21037
21038 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21039 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21040
21041 else
21042 # We're on a posix platform. Hooray! :)
21043 path="$BOOT_JDK"
21044 has_space=`$ECHO "$path" | $GREP " "`
21045 if test "x$has_space" != x; then
21046 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21047 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21048 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21049 fi
21050
21051 # Use eval to expand a potential ~
21052 eval path="$path"
21053 if test ! -f "$path" && test ! -d "$path"; then
21054 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21055 fi
21056
21057 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21058 fi
21059
21060 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21061 $as_echo_n "checking for Boot JDK... " >&6; }
21062 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21208
21209 windows_path="$new_path"
21210 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21211 unix_path=`$CYGPATH -u "$windows_path"`
21212 new_path="$unix_path"
21213 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21214 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21215 new_path="$unix_path"
21216 fi
21217
21218 if test "x$path" != "x$new_path"; then
21219 BOOT_JDK="$new_path"
21220 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21221 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21222 fi
21223
21224 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21225 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21226
21227 else
21228 # We're on a posix platform. Hooray! :)
21229 path="$BOOT_JDK"
21230 has_space=`$ECHO "$path" | $GREP " "`
21231 if test "x$has_space" != x; then
21232 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21233 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21234 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21235 fi
21236
21237 # Use eval to expand a potential ~
21238 eval path="$path"
21239 if test ! -f "$path" && test ! -d "$path"; then
21240 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21241 fi
21242
21243 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21244 fi
21245
21246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21247 $as_echo_n "checking for Boot JDK... " >&6; }
21248 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21394
21395 windows_path="$new_path"
21396 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21397 unix_path=`$CYGPATH -u "$windows_path"`
21398 new_path="$unix_path"
21399 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21400 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21401 new_path="$unix_path"
21402 fi
21403
21404 if test "x$path" != "x$new_path"; then
21405 BOOT_JDK="$new_path"
21406 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21407 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21408 fi
21409
21410 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21411 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21412
21413 else
21414 # We're on a posix platform. Hooray! :)
21415 path="$BOOT_JDK"
21416 has_space=`$ECHO "$path" | $GREP " "`
21417 if test "x$has_space" != x; then
21418 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21419 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21420 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21421 fi
21422
21423 # Use eval to expand a potential ~
21424 eval path="$path"
21425 if test ! -f "$path" && test ! -d "$path"; then
21426 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21427 fi
21428
21429 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21430 fi
21431
21432 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21433 $as_echo_n "checking for Boot JDK... " >&6; }
21434 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21571
21572 windows_path="$new_path"
21573 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21574 unix_path=`$CYGPATH -u "$windows_path"`
21575 new_path="$unix_path"
21576 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21577 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21578 new_path="$unix_path"
21579 fi
21580
21581 if test "x$path" != "x$new_path"; then
21582 BOOT_JDK="$new_path"
21583 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21584 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21585 fi
21586
21587 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21588 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21589
21590 else
21591 # We're on a posix platform. Hooray! :)
21592 path="$BOOT_JDK"
21593 has_space=`$ECHO "$path" | $GREP " "`
21594 if test "x$has_space" != x; then
21595 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21596 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21597 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21598 fi
21599
21600 # Use eval to expand a potential ~
21601 eval path="$path"
21602 if test ! -f "$path" && test ! -d "$path"; then
21603 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21604 fi
21605
21606 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21607 fi
21608
21609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21610 $as_echo_n "checking for Boot JDK... " >&6; }
21611 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21717
21718 windows_path="$new_path"
21719 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21720 unix_path=`$CYGPATH -u "$windows_path"`
21721 new_path="$unix_path"
21722 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21723 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21724 new_path="$unix_path"
21725 fi
21726
21727 if test "x$path" != "x$new_path"; then
21728 JAVA_HOME_PROCESSED="$new_path"
21729 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21730 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21731 fi
21732
21733 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21734 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21735
21736 else
21737 # We're on a posix platform. Hooray! :)
21738 path="$JAVA_HOME_PROCESSED"
21739 has_space=`$ECHO "$path" | $GREP " "`
21740 if test "x$has_space" != x; then
21741 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21742 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21743 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21744 fi
21745
21746 # Use eval to expand a potential ~
21747 eval path="$path"
21748 if test ! -f "$path" && test ! -d "$path"; then
21749 as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21750 fi
21751
21752 JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21753 fi
21754
21755 if test ! -d "$JAVA_HOME_PROCESSED"; then
21756 { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21757 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21889
21890 windows_path="$new_path"
21891 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21892 unix_path=`$CYGPATH -u "$windows_path"`
21893 new_path="$unix_path"
21894 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21895 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21896 new_path="$unix_path"
21897 fi
21898
21899 if test "x$path" != "x$new_path"; then
21900 BOOT_JDK="$new_path"
21901 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21902 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21903 fi
21904
21905 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21906 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21907
21908 else
21909 # We're on a posix platform. Hooray! :)
21910 path="$BOOT_JDK"
21911 has_space=`$ECHO "$path" | $GREP " "`
21912 if test "x$has_space" != x; then
21913 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21914 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21915 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21916 fi
21917
21918 # Use eval to expand a potential ~
21919 eval path="$path"
21920 if test ! -f "$path" && test ! -d "$path"; then
21921 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21922 fi
21923
21924 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21925 fi
21926
21927 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21928 $as_echo_n "checking for Boot JDK... " >&6; }
21929 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22217
22218 windows_path="$new_path"
22219 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22220 unix_path=`$CYGPATH -u "$windows_path"`
22221 new_path="$unix_path"
22222 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22223 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22224 new_path="$unix_path"
22225 fi
22226
22227 if test "x$path" != "x$new_path"; then
22228 BOOT_JDK="$new_path"
22229 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22230 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22231 fi
22232
22233 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22234 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22235
22236 else
22237 # We're on a posix platform. Hooray! :)
22238 path="$BOOT_JDK"
22239 has_space=`$ECHO "$path" | $GREP " "`
22240 if test "x$has_space" != x; then
22241 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22242 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22243 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22244 fi
22245
22246 # Use eval to expand a potential ~
22247 eval path="$path"
22248 if test ! -f "$path" && test ! -d "$path"; then
22249 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22250 fi
22251
22252 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22253 fi
22254
22255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22256 $as_echo_n "checking for Boot JDK... " >&6; }
22257 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22432
22433 windows_path="$new_path"
22434 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22435 unix_path=`$CYGPATH -u "$windows_path"`
22436 new_path="$unix_path"
22437 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22438 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22439 new_path="$unix_path"
22440 fi
22441
22442 if test "x$path" != "x$new_path"; then
22443 BOOT_JDK="$new_path"
22444 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22445 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22446 fi
22447
22448 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22449 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22450
22451 else
22452 # We're on a posix platform. Hooray! :)
22453 path="$BOOT_JDK"
22454 has_space=`$ECHO "$path" | $GREP " "`
22455 if test "x$has_space" != x; then
22456 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22457 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22458 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22459 fi
22460
22461 # Use eval to expand a potential ~
22462 eval path="$path"
22463 if test ! -f "$path" && test ! -d "$path"; then
22464 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22465 fi
22466
22467 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22468 fi
22469
22470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22471 $as_echo_n "checking for Boot JDK... " >&6; }
22472 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22612
22613 windows_path="$new_path"
22614 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22615 unix_path=`$CYGPATH -u "$windows_path"`
22616 new_path="$unix_path"
22617 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22618 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22619 new_path="$unix_path"
22620 fi
22621
22622 if test "x$path" != "x$new_path"; then
22623 BOOT_JDK="$new_path"
22624 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22625 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22626 fi
22627
22628 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22629 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22630
22631 else
22632 # We're on a posix platform. Hooray! :)
22633 path="$BOOT_JDK"
22634 has_space=`$ECHO "$path" | $GREP " "`
22635 if test "x$has_space" != x; then
22636 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22637 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22638 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22639 fi
22640
22641 # Use eval to expand a potential ~
22642 eval path="$path"
22643 if test ! -f "$path" && test ! -d "$path"; then
22644 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22645 fi
22646
22647 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22648 fi
22649
22650 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22651 $as_echo_n "checking for Boot JDK... " >&6; }
22652 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22820
22821 windows_path="$new_path"
22822 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22823 unix_path=`$CYGPATH -u "$windows_path"`
22824 new_path="$unix_path"
22825 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22826 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22827 new_path="$unix_path"
22828 fi
22829
22830 if test "x$path" != "x$new_path"; then
22831 BOOT_JDK="$new_path"
22832 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22833 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22834 fi
22835
22836 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22837 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22838
22839 else
22840 # We're on a posix platform. Hooray! :)
22841 path="$BOOT_JDK"
22842 has_space=`$ECHO "$path" | $GREP " "`
22843 if test "x$has_space" != x; then
22844 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22845 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22846 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22847 fi
22848
22849 # Use eval to expand a potential ~
22850 eval path="$path"
22851 if test ! -f "$path" && test ! -d "$path"; then
22852 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22853 fi
22854
22855 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22856 fi
22857
22858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22859 $as_echo_n "checking for Boot JDK... " >&6; }
22860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23000
23001 windows_path="$new_path"
23002 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23003 unix_path=`$CYGPATH -u "$windows_path"`
23004 new_path="$unix_path"
23005 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23006 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23007 new_path="$unix_path"
23008 fi
23009
23010 if test "x$path" != "x$new_path"; then
23011 BOOT_JDK="$new_path"
23012 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23013 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23014 fi
23015
23016 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23017 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23018
23019 else
23020 # We're on a posix platform. Hooray! :)
23021 path="$BOOT_JDK"
23022 has_space=`$ECHO "$path" | $GREP " "`
23023 if test "x$has_space" != x; then
23024 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23025 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23026 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23027 fi
23028
23029 # Use eval to expand a potential ~
23030 eval path="$path"
23031 if test ! -f "$path" && test ! -d "$path"; then
23032 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23033 fi
23034
23035 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23036 fi
23037
23038 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23039 $as_echo_n "checking for Boot JDK... " >&6; }
23040 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23208
23209 windows_path="$new_path"
23210 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23211 unix_path=`$CYGPATH -u "$windows_path"`
23212 new_path="$unix_path"
23213 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23214 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23215 new_path="$unix_path"
23216 fi
23217
23218 if test "x$path" != "x$new_path"; then
23219 BOOT_JDK="$new_path"
23220 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23221 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23222 fi
23223
23224 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23225 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23226
23227 else
23228 # We're on a posix platform. Hooray! :)
23229 path="$BOOT_JDK"
23230 has_space=`$ECHO "$path" | $GREP " "`
23231 if test "x$has_space" != x; then
23232 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23233 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23234 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23235 fi
23236
23237 # Use eval to expand a potential ~
23238 eval path="$path"
23239 if test ! -f "$path" && test ! -d "$path"; then
23240 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23241 fi
23242
23243 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23244 fi
23245
23246 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23247 $as_echo_n "checking for Boot JDK... " >&6; }
23248 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23388
23389 windows_path="$new_path"
23390 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23391 unix_path=`$CYGPATH -u "$windows_path"`
23392 new_path="$unix_path"
23393 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23394 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23395 new_path="$unix_path"
23396 fi
23397
23398 if test "x$path" != "x$new_path"; then
23399 BOOT_JDK="$new_path"
23400 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23401 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23402 fi
23403
23404 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23405 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23406
23407 else
23408 # We're on a posix platform. Hooray! :)
23409 path="$BOOT_JDK"
23410 has_space=`$ECHO "$path" | $GREP " "`
23411 if test "x$has_space" != x; then
23412 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23413 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23414 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23415 fi
23416
23417 # Use eval to expand a potential ~
23418 eval path="$path"
23419 if test ! -f "$path" && test ! -d "$path"; then
23420 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23421 fi
23422
23423 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23424 fi
23425
23426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23427 $as_echo_n "checking for Boot JDK... " >&6; }
23428 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23596
23597 windows_path="$new_path"
23598 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23599 unix_path=`$CYGPATH -u "$windows_path"`
23600 new_path="$unix_path"
23601 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23602 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23603 new_path="$unix_path"
23604 fi
23605
23606 if test "x$path" != "x$new_path"; then
23607 BOOT_JDK="$new_path"
23608 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23609 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23610 fi
23611
23612 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23613 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23614
23615 else
23616 # We're on a posix platform. Hooray! :)
23617 path="$BOOT_JDK"
23618 has_space=`$ECHO "$path" | $GREP " "`
23619 if test "x$has_space" != x; then
23620 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23621 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23622 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23623 fi
23624
23625 # Use eval to expand a potential ~
23626 eval path="$path"
23627 if test ! -f "$path" && test ! -d "$path"; then
23628 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23629 fi
23630
23631 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23632 fi
23633
23634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23635 $as_echo_n "checking for Boot JDK... " >&6; }
23636 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23776
23777 windows_path="$new_path"
23778 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23779 unix_path=`$CYGPATH -u "$windows_path"`
23780 new_path="$unix_path"
23781 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23782 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23783 new_path="$unix_path"
23784 fi
23785
23786 if test "x$path" != "x$new_path"; then
23787 BOOT_JDK="$new_path"
23788 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23789 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23790 fi
23791
23792 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23793 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23794
23795 else
23796 # We're on a posix platform. Hooray! :)
23797 path="$BOOT_JDK"
23798 has_space=`$ECHO "$path" | $GREP " "`
23799 if test "x$has_space" != x; then
23800 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23801 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23802 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23803 fi
23804
23805 # Use eval to expand a potential ~
23806 eval path="$path"
23807 if test ! -f "$path" && test ! -d "$path"; then
23808 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23809 fi
23810
23811 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23812 fi
23813
23814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23815 $as_echo_n "checking for Boot JDK... " >&6; }
23816 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23971
23972 windows_path="$new_path"
23973 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23974 unix_path=`$CYGPATH -u "$windows_path"`
23975 new_path="$unix_path"
23976 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23977 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23978 new_path="$unix_path"
23979 fi
23980
23981 if test "x$path" != "x$new_path"; then
23982 BOOT_JDK="$new_path"
23983 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23984 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23985 fi
23986
23987 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23988 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23989
23990 else
23991 # We're on a posix platform. Hooray! :)
23992 path="$BOOT_JDK"
23993 has_space=`$ECHO "$path" | $GREP " "`
23994 if test "x$has_space" != x; then
23995 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23996 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23997 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23998 fi
23999
24000 # Use eval to expand a potential ~
24001 eval path="$path"
24002 if test ! -f "$path" && test ! -d "$path"; then
24003 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24004 fi
24005
24006 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24007 fi
24008
24009 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24010 $as_echo_n "checking for Boot JDK... " >&6; }
24011 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24149
24150 windows_path="$new_path"
24151 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24152 unix_path=`$CYGPATH -u "$windows_path"`
24153 new_path="$unix_path"
24154 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24155 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24156 new_path="$unix_path"
24157 fi
24158
24159 if test "x$path" != "x$new_path"; then
24160 BOOT_JDK="$new_path"
24161 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24162 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24163 fi
24164
24165 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24166 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24167
24168 else
24169 # We're on a posix platform. Hooray! :)
24170 path="$BOOT_JDK"
24171 has_space=`$ECHO "$path" | $GREP " "`
24172 if test "x$has_space" != x; then
24173 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24174 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24175 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24176 fi
24177
24178 # Use eval to expand a potential ~
24179 eval path="$path"
24180 if test ! -f "$path" && test ! -d "$path"; then
24181 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24182 fi
24183
24184 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24185 fi
24186
24187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24188 $as_echo_n "checking for Boot JDK... " >&6; }
24189 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24345
24346 windows_path="$new_path"
24347 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24348 unix_path=`$CYGPATH -u "$windows_path"`
24349 new_path="$unix_path"
24350 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24351 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24352 new_path="$unix_path"
24353 fi
24354
24355 if test "x$path" != "x$new_path"; then
24356 BOOT_JDK="$new_path"
24357 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24358 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24359 fi
24360
24361 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24362 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24363
24364 else
24365 # We're on a posix platform. Hooray! :)
24366 path="$BOOT_JDK"
24367 has_space=`$ECHO "$path" | $GREP " "`
24368 if test "x$has_space" != x; then
24369 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24370 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24371 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24372 fi
24373
24374 # Use eval to expand a potential ~
24375 eval path="$path"
24376 if test ! -f "$path" && test ! -d "$path"; then
24377 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24378 fi
24379
24380 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24381 fi
24382
24383 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24384 $as_echo_n "checking for Boot JDK... " >&6; }
24385 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24523
24524 windows_path="$new_path"
24525 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24526 unix_path=`$CYGPATH -u "$windows_path"`
24527 new_path="$unix_path"
24528 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24529 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24530 new_path="$unix_path"
24531 fi
24532
24533 if test "x$path" != "x$new_path"; then
24534 BOOT_JDK="$new_path"
24535 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24536 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24537 fi
24538
24539 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24540 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24541
24542 else
24543 # We're on a posix platform. Hooray! :)
24544 path="$BOOT_JDK"
24545 has_space=`$ECHO "$path" | $GREP " "`
24546 if test "x$has_space" != x; then
24547 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24548 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24549 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24550 fi
24551
24552 # Use eval to expand a potential ~
24553 eval path="$path"
24554 if test ! -f "$path" && test ! -d "$path"; then
24555 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24556 fi
24557
24558 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24559 fi
24560
24561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24562 $as_echo_n "checking for Boot JDK... " >&6; }
24563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24718
24719 windows_path="$new_path"
24720 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24721 unix_path=`$CYGPATH -u "$windows_path"`
24722 new_path="$unix_path"
24723 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24724 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24725 new_path="$unix_path"
24726 fi
24727
24728 if test "x$path" != "x$new_path"; then
24729 BOOT_JDK="$new_path"
24730 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24731 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24732 fi
24733
24734 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24735 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24736
24737 else
24738 # We're on a posix platform. Hooray! :)
24739 path="$BOOT_JDK"
24740 has_space=`$ECHO "$path" | $GREP " "`
24741 if test "x$has_space" != x; then
24742 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24743 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24744 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24745 fi
24746
24747 # Use eval to expand a potential ~
24748 eval path="$path"
24749 if test ! -f "$path" && test ! -d "$path"; then
24750 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24751 fi
24752
24753 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24754 fi
24755
24756 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24757 $as_echo_n "checking for Boot JDK... " >&6; }
24758 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24896
24897 windows_path="$new_path"
24898 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24899 unix_path=`$CYGPATH -u "$windows_path"`
24900 new_path="$unix_path"
24901 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24902 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24903 new_path="$unix_path"
24904 fi
24905
24906 if test "x$path" != "x$new_path"; then
24907 BOOT_JDK="$new_path"
24908 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24909 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24910 fi
24911
24912 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24913 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24914
24915 else
24916 # We're on a posix platform. Hooray! :)
24917 path="$BOOT_JDK"
24918 has_space=`$ECHO "$path" | $GREP " "`
24919 if test "x$has_space" != x; then
24920 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24921 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24922 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24923 fi
24924
24925 # Use eval to expand a potential ~
24926 eval path="$path"
24927 if test ! -f "$path" && test ! -d "$path"; then
24928 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24929 fi
24930
24931 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24932 fi
24933
24934 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24935 $as_echo_n "checking for Boot JDK... " >&6; }
24936 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25092
25093 windows_path="$new_path"
25094 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25095 unix_path=`$CYGPATH -u "$windows_path"`
25096 new_path="$unix_path"
25097 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25098 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25099 new_path="$unix_path"
25100 fi
25101
25102 if test "x$path" != "x$new_path"; then
25103 BOOT_JDK="$new_path"
25104 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25105 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25106 fi
25107
25108 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25109 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25110
25111 else
25112 # We're on a posix platform. Hooray! :)
25113 path="$BOOT_JDK"
25114 has_space=`$ECHO "$path" | $GREP " "`
25115 if test "x$has_space" != x; then
25116 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25117 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25118 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25119 fi
25120
25121 # Use eval to expand a potential ~
25122 eval path="$path"
25123 if test ! -f "$path" && test ! -d "$path"; then
25124 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25125 fi
25126
25127 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25128 fi
25129
25130 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25131 $as_echo_n "checking for Boot JDK... " >&6; }
25132 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25270
25271 windows_path="$new_path"
25272 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25273 unix_path=`$CYGPATH -u "$windows_path"`
25274 new_path="$unix_path"
25275 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25276 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25277 new_path="$unix_path"
25278 fi
25279
25280 if test "x$path" != "x$new_path"; then
25281 BOOT_JDK="$new_path"
25282 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25283 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25284 fi
25285
25286 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25287 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25288
25289 else
25290 # We're on a posix platform. Hooray! :)
25291 path="$BOOT_JDK"
25292 has_space=`$ECHO "$path" | $GREP " "`
25293 if test "x$has_space" != x; then
25294 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25295 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25296 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25297 fi
25298
25299 # Use eval to expand a potential ~
25300 eval path="$path"
25301 if test ! -f "$path" && test ! -d "$path"; then
25302 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25303 fi
25304
25305 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25306 fi
25307
25308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25309 $as_echo_n "checking for Boot JDK... " >&6; }
25310 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25447
25448 windows_path="$new_path"
25449 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25450 unix_path=`$CYGPATH -u "$windows_path"`
25451 new_path="$unix_path"
25452 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25453 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25454 new_path="$unix_path"
25455 fi
25456
25457 if test "x$path" != "x$new_path"; then
25458 BOOT_JDK="$new_path"
25459 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25460 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25461 fi
25462
25463 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25464 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25465
25466 else
25467 # We're on a posix platform. Hooray! :)
25468 path="$BOOT_JDK"
25469 has_space=`$ECHO "$path" | $GREP " "`
25470 if test "x$has_space" != x; then
25471 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25472 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25473 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25474 fi
25475
25476 # Use eval to expand a potential ~
25477 eval path="$path"
25478 if test ! -f "$path" && test ! -d "$path"; then
25479 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25480 fi
25481
25482 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25483 fi
25484
25485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25486 $as_echo_n "checking for Boot JDK... " >&6; }
25487 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27488
27489 # Output is in $new_path
27490
27491 windows_path="$new_path"
27492 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27493 unix_path=`$CYGPATH -u "$windows_path"`
27494 new_path="$unix_path"
27495 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27496 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27497 new_path="$unix_path"
27498 fi
27499
27500 # remove trailing .exe if any
27501 new_path="${new_path/%.exe/}"
27502
27503 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27504 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27505 fi
27506
27507 else
27508 # We're on a posix platform. Hooray! :)
27509 # First separate the path from the arguments. This will split at the first
27510 # space.
27511 complete="$VS_ENV_CMD"
27512 path="${complete%% *}"
27513 tmp="$complete EOL"
27514 arguments="${tmp#* }"
27515
27516 # Cannot rely on the command "which" here since it doesn't always work.
27517 is_absolute_path=`$ECHO "$path" | $GREP ^/`
27518 if test -z "$is_absolute_path"; then
27519 # Path to executable is not absolute. Find it.
27520 IFS_save="$IFS"
27521 IFS=:
27522 for p in $PATH; do
27523 if test -f "$p/$path" && test -x "$p/$path"; then
27524 new_path="$p/$path"
27525 break
27526 fi
27527 done
27528 IFS="$IFS_save"
28148
28149 # Output is in $new_path
28150
28151 windows_path="$new_path"
28152 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28153 unix_path=`$CYGPATH -u "$windows_path"`
28154 new_path="$unix_path"
28155 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28156 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28157 new_path="$unix_path"
28158 fi
28159
28160 # remove trailing .exe if any
28161 new_path="${new_path/%.exe/}"
28162
28163 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28164 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28165 fi
28166
28167 else
28168 # We're on a posix platform. Hooray! :)
28169 # First separate the path from the arguments. This will split at the first
28170 # space.
28171 complete="$CC"
28172 path="${complete%% *}"
28173 tmp="$complete EOL"
28174 arguments="${tmp#* }"
28175
28176 # Cannot rely on the command "which" here since it doesn't always work.
28177 is_absolute_path=`$ECHO "$path" | $GREP ^/`
28178 if test -z "$is_absolute_path"; then
28179 # Path to executable is not absolute. Find it.
28180 IFS_save="$IFS"
28181 IFS=:
28182 for p in $PATH; do
28183 if test -f "$p/$path" && test -x "$p/$path"; then
28184 new_path="$p/$path"
28185 break
28186 fi
28187 done
28188 IFS="$IFS_save"
28605
28606 # Output is in $new_path
28607
28608 windows_path="$new_path"
28609 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28610 unix_path=`$CYGPATH -u "$windows_path"`
28611 new_path="$unix_path"
28612 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28613 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28614 new_path="$unix_path"
28615 fi
28616
28617 # remove trailing .exe if any
28618 new_path="${new_path/%.exe/}"
28619
28620 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28621 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28622 fi
28623
28624 else
28625 # We're on a posix platform. Hooray! :)
28626 # First separate the path from the arguments. This will split at the first
28627 # space.
28628 complete="$PROPER_COMPILER_CC"
28629 path="${complete%% *}"
28630 tmp="$complete EOL"
28631 arguments="${tmp#* }"
28632
28633 # Cannot rely on the command "which" here since it doesn't always work.
28634 is_absolute_path=`$ECHO "$path" | $GREP ^/`
28635 if test -z "$is_absolute_path"; then
28636 # Path to executable is not absolute. Find it.
28637 IFS_save="$IFS"
28638 IFS=:
28639 for p in $PATH; do
28640 if test -f "$p/$path" && test -x "$p/$path"; then
28641 new_path="$p/$path"
28642 break
28643 fi
28644 done
28645 IFS="$IFS_save"
29888
29889 # Output is in $new_path
29890
29891 windows_path="$new_path"
29892 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29893 unix_path=`$CYGPATH -u "$windows_path"`
29894 new_path="$unix_path"
29895 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29896 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29897 new_path="$unix_path"
29898 fi
29899
29900 # remove trailing .exe if any
29901 new_path="${new_path/%.exe/}"
29902
29903 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29904 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29905 fi
29906
29907 else
29908 # We're on a posix platform. Hooray! :)
29909 # First separate the path from the arguments. This will split at the first
29910 # space.
29911 complete="$CXX"
29912 path="${complete%% *}"
29913 tmp="$complete EOL"
29914 arguments="${tmp#* }"
29915
29916 # Cannot rely on the command "which" here since it doesn't always work.
29917 is_absolute_path=`$ECHO "$path" | $GREP ^/`
29918 if test -z "$is_absolute_path"; then
29919 # Path to executable is not absolute. Find it.
29920 IFS_save="$IFS"
29921 IFS=:
29922 for p in $PATH; do
29923 if test -f "$p/$path" && test -x "$p/$path"; then
29924 new_path="$p/$path"
29925 break
29926 fi
29927 done
29928 IFS="$IFS_save"
30345
30346 # Output is in $new_path
30347
30348 windows_path="$new_path"
30349 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30350 unix_path=`$CYGPATH -u "$windows_path"`
30351 new_path="$unix_path"
30352 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30353 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
30354 new_path="$unix_path"
30355 fi
30356
30357 # remove trailing .exe if any
30358 new_path="${new_path/%.exe/}"
30359
30360 # Save the first 10 bytes of this path to the storage, so fixpath can work.
30361 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
30362 fi
30363
30364 else
30365 # We're on a posix platform. Hooray! :)
30366 # First separate the path from the arguments. This will split at the first
30367 # space.
30368 complete="$PROPER_COMPILER_CXX"
30369 path="${complete%% *}"
30370 tmp="$complete EOL"
30371 arguments="${tmp#* }"
30372
30373 # Cannot rely on the command "which" here since it doesn't always work.
30374 is_absolute_path=`$ECHO "$path" | $GREP ^/`
30375 if test -z "$is_absolute_path"; then
30376 # Path to executable is not absolute. Find it.
30377 IFS_save="$IFS"
30378 IFS=:
30379 for p in $PATH; do
30380 if test -f "$p/$path" && test -x "$p/$path"; then
30381 new_path="$p/$path"
30382 break
30383 fi
30384 done
30385 IFS="$IFS_save"
31207
31208 # Output is in $new_path
31209
31210 windows_path="$new_path"
31211 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31212 unix_path=`$CYGPATH -u "$windows_path"`
31213 new_path="$unix_path"
31214 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31215 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31216 new_path="$unix_path"
31217 fi
31218
31219 # remove trailing .exe if any
31220 new_path="${new_path/%.exe/}"
31221
31222 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31223 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31224 fi
31225
31226 else
31227 # We're on a posix platform. Hooray! :)
31228 # First separate the path from the arguments. This will split at the first
31229 # space.
31230 complete="$CPP"
31231 path="${complete%% *}"
31232 tmp="$complete EOL"
31233 arguments="${tmp#* }"
31234
31235 # Cannot rely on the command "which" here since it doesn't always work.
31236 is_absolute_path=`$ECHO "$path" | $GREP ^/`
31237 if test -z "$is_absolute_path"; then
31238 # Path to executable is not absolute. Find it.
31239 IFS_save="$IFS"
31240 IFS=:
31241 for p in $PATH; do
31242 if test -f "$p/$path" && test -x "$p/$path"; then
31243 new_path="$p/$path"
31244 break
31245 fi
31246 done
31247 IFS="$IFS_save"
31622
31623 # Output is in $new_path
31624
31625 windows_path="$new_path"
31626 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31627 unix_path=`$CYGPATH -u "$windows_path"`
31628 new_path="$unix_path"
31629 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31630 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31631 new_path="$unix_path"
31632 fi
31633
31634 # remove trailing .exe if any
31635 new_path="${new_path/%.exe/}"
31636
31637 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31638 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31639 fi
31640
31641 else
31642 # We're on a posix platform. Hooray! :)
31643 # First separate the path from the arguments. This will split at the first
31644 # space.
31645 complete="$CXXCPP"
31646 path="${complete%% *}"
31647 tmp="$complete EOL"
31648 arguments="${tmp#* }"
31649
31650 # Cannot rely on the command "which" here since it doesn't always work.
31651 is_absolute_path=`$ECHO "$path" | $GREP ^/`
31652 if test -z "$is_absolute_path"; then
31653 # Path to executable is not absolute. Find it.
31654 IFS_save="$IFS"
31655 IFS=:
31656 for p in $PATH; do
31657 if test -f "$p/$path" && test -x "$p/$path"; then
31658 new_path="$p/$path"
31659 break
31660 fi
31661 done
31662 IFS="$IFS_save"
31966
31967 # Output is in $new_path
31968
31969 windows_path="$new_path"
31970 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31971 unix_path=`$CYGPATH -u "$windows_path"`
31972 new_path="$unix_path"
31973 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31974 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31975 new_path="$unix_path"
31976 fi
31977
31978 # remove trailing .exe if any
31979 new_path="${new_path/%.exe/}"
31980
31981 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31982 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31983 fi
31984
31985 else
31986 # We're on a posix platform. Hooray! :)
31987 # First separate the path from the arguments. This will split at the first
31988 # space.
31989 complete="$LD"
31990 path="${complete%% *}"
31991 tmp="$complete EOL"
31992 arguments="${tmp#* }"
31993
31994 # Cannot rely on the command "which" here since it doesn't always work.
31995 is_absolute_path=`$ECHO "$path" | $GREP ^/`
31996 if test -z "$is_absolute_path"; then
31997 # Path to executable is not absolute. Find it.
31998 IFS_save="$IFS"
31999 IFS=:
32000 for p in $PATH; do
32001 if test -f "$p/$path" && test -x "$p/$path"; then
32002 new_path="$p/$path"
32003 break
32004 fi
32005 done
32006 IFS="$IFS_save"
32461
32462 # Output is in $new_path
32463
32464 windows_path="$new_path"
32465 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32466 unix_path=`$CYGPATH -u "$windows_path"`
32467 new_path="$unix_path"
32468 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32469 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32470 new_path="$unix_path"
32471 fi
32472
32473 # remove trailing .exe if any
32474 new_path="${new_path/%.exe/}"
32475
32476 # Save the first 10 bytes of this path to the storage, so fixpath can work.
32477 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
32478 fi
32479
32480 else
32481 # We're on a posix platform. Hooray! :)
32482 # First separate the path from the arguments. This will split at the first
32483 # space.
32484 complete="$AS"
32485 path="${complete%% *}"
32486 tmp="$complete EOL"
32487 arguments="${tmp#* }"
32488
32489 # Cannot rely on the command "which" here since it doesn't always work.
32490 is_absolute_path=`$ECHO "$path" | $GREP ^/`
32491 if test -z "$is_absolute_path"; then
32492 # Path to executable is not absolute. Find it.
32493 IFS_save="$IFS"
32494 IFS=:
32495 for p in $PATH; do
32496 if test -f "$p/$path" && test -x "$p/$path"; then
32497 new_path="$p/$path"
32498 break
32499 fi
32500 done
32501 IFS="$IFS_save"
33089
33090 # Output is in $new_path
33091
33092 windows_path="$new_path"
33093 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33094 unix_path=`$CYGPATH -u "$windows_path"`
33095 new_path="$unix_path"
33096 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33097 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33098 new_path="$unix_path"
33099 fi
33100
33101 # remove trailing .exe if any
33102 new_path="${new_path/%.exe/}"
33103
33104 # Save the first 10 bytes of this path to the storage, so fixpath can work.
33105 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
33106 fi
33107
33108 else
33109 # We're on a posix platform. Hooray! :)
33110 # First separate the path from the arguments. This will split at the first
33111 # space.
33112 complete="$AR"
33113 path="${complete%% *}"
33114 tmp="$complete EOL"
33115 arguments="${tmp#* }"
33116
33117 # Cannot rely on the command "which" here since it doesn't always work.
33118 is_absolute_path=`$ECHO "$path" | $GREP ^/`
33119 if test -z "$is_absolute_path"; then
33120 # Path to executable is not absolute. Find it.
33121 IFS_save="$IFS"
33122 IFS=:
33123 for p in $PATH; do
33124 if test -f "$p/$path" && test -x "$p/$path"; then
33125 new_path="$p/$path"
33126 break
33127 fi
33128 done
33129 IFS="$IFS_save"
33625
33626 # Output is in $new_path
33627
33628 windows_path="$new_path"
33629 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33630 unix_path=`$CYGPATH -u "$windows_path"`
33631 new_path="$unix_path"
33632 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33633 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33634 new_path="$unix_path"
33635 fi
33636
33637 # remove trailing .exe if any
33638 new_path="${new_path/%.exe/}"
33639
33640 # Save the first 10 bytes of this path to the storage, so fixpath can work.
33641 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
33642 fi
33643
33644 else
33645 # We're on a posix platform. Hooray! :)
33646 # First separate the path from the arguments. This will split at the first
33647 # space.
33648 complete="$OBJC"
33649 path="${complete%% *}"
33650 tmp="$complete EOL"
33651 arguments="${tmp#* }"
33652
33653 # Cannot rely on the command "which" here since it doesn't always work.
33654 is_absolute_path=`$ECHO "$path" | $GREP ^/`
33655 if test -z "$is_absolute_path"; then
33656 # Path to executable is not absolute. Find it.
33657 IFS_save="$IFS"
33658 IFS=:
33659 for p in $PATH; do
33660 if test -f "$p/$path" && test -x "$p/$path"; then
33661 new_path="$p/$path"
33662 break
33663 fi
33664 done
33665 IFS="$IFS_save"
34093
34094 # Output is in $new_path
34095
34096 windows_path="$new_path"
34097 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34098 unix_path=`$CYGPATH -u "$windows_path"`
34099 new_path="$unix_path"
34100 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34101 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34102 new_path="$unix_path"
34103 fi
34104
34105 # remove trailing .exe if any
34106 new_path="${new_path/%.exe/}"
34107
34108 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34109 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34110 fi
34111
34112 else
34113 # We're on a posix platform. Hooray! :)
34114 # First separate the path from the arguments. This will split at the first
34115 # space.
34116 complete="$LIPO"
34117 path="${complete%% *}"
34118 tmp="$complete EOL"
34119 arguments="${tmp#* }"
34120
34121 # Cannot rely on the command "which" here since it doesn't always work.
34122 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34123 if test -z "$is_absolute_path"; then
34124 # Path to executable is not absolute. Find it.
34125 IFS_save="$IFS"
34126 IFS=:
34127 for p in $PATH; do
34128 if test -f "$p/$path" && test -x "$p/$path"; then
34129 new_path="$p/$path"
34130 break
34131 fi
34132 done
34133 IFS="$IFS_save"
34434
34435 # Output is in $new_path
34436
34437 windows_path="$new_path"
34438 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34439 unix_path=`$CYGPATH -u "$windows_path"`
34440 new_path="$unix_path"
34441 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34442 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34443 new_path="$unix_path"
34444 fi
34445
34446 # remove trailing .exe if any
34447 new_path="${new_path/%.exe/}"
34448
34449 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34450 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34451 fi
34452
34453 else
34454 # We're on a posix platform. Hooray! :)
34455 # First separate the path from the arguments. This will split at the first
34456 # space.
34457 complete="$MT"
34458 path="${complete%% *}"
34459 tmp="$complete EOL"
34460 arguments="${tmp#* }"
34461
34462 # Cannot rely on the command "which" here since it doesn't always work.
34463 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34464 if test -z "$is_absolute_path"; then
34465 # Path to executable is not absolute. Find it.
34466 IFS_save="$IFS"
34467 IFS=:
34468 for p in $PATH; do
34469 if test -f "$p/$path" && test -x "$p/$path"; then
34470 new_path="$p/$path"
34471 break
34472 fi
34473 done
34474 IFS="$IFS_save"
34771
34772 # Output is in $new_path
34773
34774 windows_path="$new_path"
34775 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34776 unix_path=`$CYGPATH -u "$windows_path"`
34777 new_path="$unix_path"
34778 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34779 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34780 new_path="$unix_path"
34781 fi
34782
34783 # remove trailing .exe if any
34784 new_path="${new_path/%.exe/}"
34785
34786 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34787 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34788 fi
34789
34790 else
34791 # We're on a posix platform. Hooray! :)
34792 # First separate the path from the arguments. This will split at the first
34793 # space.
34794 complete="$RC"
34795 path="${complete%% *}"
34796 tmp="$complete EOL"
34797 arguments="${tmp#* }"
34798
34799 # Cannot rely on the command "which" here since it doesn't always work.
34800 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34801 if test -z "$is_absolute_path"; then
34802 # Path to executable is not absolute. Find it.
34803 IFS_save="$IFS"
34804 IFS=:
34805 for p in $PATH; do
34806 if test -f "$p/$path" && test -x "$p/$path"; then
34807 new_path="$p/$path"
34808 break
34809 fi
34810 done
34811 IFS="$IFS_save"
35090
35091 # Output is in $new_path
35092
35093 windows_path="$new_path"
35094 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35095 unix_path=`$CYGPATH -u "$windows_path"`
35096 new_path="$unix_path"
35097 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35098 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35099 new_path="$unix_path"
35100 fi
35101
35102 # remove trailing .exe if any
35103 new_path="${new_path/%.exe/}"
35104
35105 # Save the first 10 bytes of this path to the storage, so fixpath can work.
35106 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
35107 fi
35108
35109 else
35110 # We're on a posix platform. Hooray! :)
35111 # First separate the path from the arguments. This will split at the first
35112 # space.
35113 complete="$DUMPBIN"
35114 path="${complete%% *}"
35115 tmp="$complete EOL"
35116 arguments="${tmp#* }"
35117
35118 # Cannot rely on the command "which" here since it doesn't always work.
35119 is_absolute_path=`$ECHO "$path" | $GREP ^/`
35120 if test -z "$is_absolute_path"; then
35121 # Path to executable is not absolute. Find it.
35122 IFS_save="$IFS"
35123 IFS=:
35124 for p in $PATH; do
35125 if test -f "$p/$path" && test -x "$p/$path"; then
35126 new_path="$p/$path"
35127 break
35128 fi
35129 done
35130 IFS="$IFS_save"
35605
35606 # Output is in $new_path
35607
35608 windows_path="$new_path"
35609 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35610 unix_path=`$CYGPATH -u "$windows_path"`
35611 new_path="$unix_path"
35612 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35613 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35614 new_path="$unix_path"
35615 fi
35616
35617 # remove trailing .exe if any
35618 new_path="${new_path/%.exe/}"
35619
35620 # Save the first 10 bytes of this path to the storage, so fixpath can work.
35621 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
35622 fi
35623
35624 else
35625 # We're on a posix platform. Hooray! :)
35626 # First separate the path from the arguments. This will split at the first
35627 # space.
35628 complete="$STRIP"
35629 path="${complete%% *}"
35630 tmp="$complete EOL"
35631 arguments="${tmp#* }"
35632
35633 # Cannot rely on the command "which" here since it doesn't always work.
35634 is_absolute_path=`$ECHO "$path" | $GREP ^/`
35635 if test -z "$is_absolute_path"; then
35636 # Path to executable is not absolute. Find it.
35637 IFS_save="$IFS"
35638 IFS=:
35639 for p in $PATH; do
35640 if test -f "$p/$path" && test -x "$p/$path"; then
35641 new_path="$p/$path"
35642 break
35643 fi
35644 done
35645 IFS="$IFS_save"
36073
36074 # Output is in $new_path
36075
36076 windows_path="$new_path"
36077 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36078 unix_path=`$CYGPATH -u "$windows_path"`
36079 new_path="$unix_path"
36080 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36081 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36082 new_path="$unix_path"
36083 fi
36084
36085 # remove trailing .exe if any
36086 new_path="${new_path/%.exe/}"
36087
36088 # Save the first 10 bytes of this path to the storage, so fixpath can work.
36089 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
36090 fi
36091
36092 else
36093 # We're on a posix platform. Hooray! :)
36094 # First separate the path from the arguments. This will split at the first
36095 # space.
36096 complete="$NM"
36097 path="${complete%% *}"
36098 tmp="$complete EOL"
36099 arguments="${tmp#* }"
36100
36101 # Cannot rely on the command "which" here since it doesn't always work.
36102 is_absolute_path=`$ECHO "$path" | $GREP ^/`
36103 if test -z "$is_absolute_path"; then
36104 # Path to executable is not absolute. Find it.
36105 IFS_save="$IFS"
36106 IFS=:
36107 for p in $PATH; do
36108 if test -f "$p/$path" && test -x "$p/$path"; then
36109 new_path="$p/$path"
36110 break
36111 fi
36112 done
36113 IFS="$IFS_save"
36541
36542 # Output is in $new_path
36543
36544 windows_path="$new_path"
36545 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36546 unix_path=`$CYGPATH -u "$windows_path"`
36547 new_path="$unix_path"
36548 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36549 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36550 new_path="$unix_path"
36551 fi
36552
36553 # remove trailing .exe if any
36554 new_path="${new_path/%.exe/}"
36555
36556 # Save the first 10 bytes of this path to the storage, so fixpath can work.
36557 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
36558 fi
36559
36560 else
36561 # We're on a posix platform. Hooray! :)
36562 # First separate the path from the arguments. This will split at the first
36563 # space.
36564 complete="$GNM"
36565 path="${complete%% *}"
36566 tmp="$complete EOL"
36567 arguments="${tmp#* }"
36568
36569 # Cannot rely on the command "which" here since it doesn't always work.
36570 is_absolute_path=`$ECHO "$path" | $GREP ^/`
36571 if test -z "$is_absolute_path"; then
36572 # Path to executable is not absolute. Find it.
36573 IFS_save="$IFS"
36574 IFS=:
36575 for p in $PATH; do
36576 if test -f "$p/$path" && test -x "$p/$path"; then
36577 new_path="$p/$path"
36578 break
36579 fi
36580 done
36581 IFS="$IFS_save"
37010
37011 # Output is in $new_path
37012
37013 windows_path="$new_path"
37014 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37015 unix_path=`$CYGPATH -u "$windows_path"`
37016 new_path="$unix_path"
37017 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37018 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37019 new_path="$unix_path"
37020 fi
37021
37022 # remove trailing .exe if any
37023 new_path="${new_path/%.exe/}"
37024
37025 # Save the first 10 bytes of this path to the storage, so fixpath can work.
37026 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
37027 fi
37028
37029 else
37030 # We're on a posix platform. Hooray! :)
37031 # First separate the path from the arguments. This will split at the first
37032 # space.
37033 complete="$MCS"
37034 path="${complete%% *}"
37035 tmp="$complete EOL"
37036 arguments="${tmp#* }"
37037
37038 # Cannot rely on the command "which" here since it doesn't always work.
37039 is_absolute_path=`$ECHO "$path" | $GREP ^/`
37040 if test -z "$is_absolute_path"; then
37041 # Path to executable is not absolute. Find it.
37042 IFS_save="$IFS"
37043 IFS=:
37044 for p in $PATH; do
37045 if test -f "$p/$path" && test -x "$p/$path"; then
37046 new_path="$p/$path"
37047 break
37048 fi
37049 done
37050 IFS="$IFS_save"
37590
37591 # Output is in $new_path
37592
37593 windows_path="$new_path"
37594 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37595 unix_path=`$CYGPATH -u "$windows_path"`
37596 new_path="$unix_path"
37597 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37598 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37599 new_path="$unix_path"
37600 fi
37601
37602 # remove trailing .exe if any
37603 new_path="${new_path/%.exe/}"
37604
37605 # Save the first 10 bytes of this path to the storage, so fixpath can work.
37606 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
37607 fi
37608
37609 else
37610 # We're on a posix platform. Hooray! :)
37611 # First separate the path from the arguments. This will split at the first
37612 # space.
37613 complete="$STRIP"
37614 path="${complete%% *}"
37615 tmp="$complete EOL"
37616 arguments="${tmp#* }"
37617
37618 # Cannot rely on the command "which" here since it doesn't always work.
37619 is_absolute_path=`$ECHO "$path" | $GREP ^/`
37620 if test -z "$is_absolute_path"; then
37621 # Path to executable is not absolute. Find it.
37622 IFS_save="$IFS"
37623 IFS=:
37624 for p in $PATH; do
37625 if test -f "$p/$path" && test -x "$p/$path"; then
37626 new_path="$p/$path"
37627 break
37628 fi
37629 done
37630 IFS="$IFS_save"
38168
38169 # Output is in $new_path
38170
38171 windows_path="$new_path"
38172 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38173 unix_path=`$CYGPATH -u "$windows_path"`
38174 new_path="$unix_path"
38175 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38176 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38177 new_path="$unix_path"
38178 fi
38179
38180 # remove trailing .exe if any
38181 new_path="${new_path/%.exe/}"
38182
38183 # Save the first 10 bytes of this path to the storage, so fixpath can work.
38184 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
38185 fi
38186
38187 else
38188 # We're on a posix platform. Hooray! :)
38189 # First separate the path from the arguments. This will split at the first
38190 # space.
38191 complete="$NM"
38192 path="${complete%% *}"
38193 tmp="$complete EOL"
38194 arguments="${tmp#* }"
38195
38196 # Cannot rely on the command "which" here since it doesn't always work.
38197 is_absolute_path=`$ECHO "$path" | $GREP ^/`
38198 if test -z "$is_absolute_path"; then
38199 # Path to executable is not absolute. Find it.
38200 IFS_save="$IFS"
38201 IFS=:
38202 for p in $PATH; do
38203 if test -f "$p/$path" && test -x "$p/$path"; then
38204 new_path="$p/$path"
38205 break
38206 fi
38207 done
38208 IFS="$IFS_save"
38755
38756 # Output is in $new_path
38757
38758 windows_path="$new_path"
38759 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38760 unix_path=`$CYGPATH -u "$windows_path"`
38761 new_path="$unix_path"
38762 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38763 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38764 new_path="$unix_path"
38765 fi
38766
38767 # remove trailing .exe if any
38768 new_path="${new_path/%.exe/}"
38769
38770 # Save the first 10 bytes of this path to the storage, so fixpath can work.
38771 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
38772 fi
38773
38774 else
38775 # We're on a posix platform. Hooray! :)
38776 # First separate the path from the arguments. This will split at the first
38777 # space.
38778 complete="$OBJCOPY"
38779 path="${complete%% *}"
38780 tmp="$complete EOL"
38781 arguments="${tmp#* }"
38782
38783 # Cannot rely on the command "which" here since it doesn't always work.
38784 is_absolute_path=`$ECHO "$path" | $GREP ^/`
38785 if test -z "$is_absolute_path"; then
38786 # Path to executable is not absolute. Find it.
38787 IFS_save="$IFS"
38788 IFS=:
38789 for p in $PATH; do
38790 if test -f "$p/$path" && test -x "$p/$path"; then
38791 new_path="$p/$path"
38792 break
38793 fi
38794 done
38795 IFS="$IFS_save"
39339
39340 # Output is in $new_path
39341
39342 windows_path="$new_path"
39343 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39344 unix_path=`$CYGPATH -u "$windows_path"`
39345 new_path="$unix_path"
39346 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39347 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39348 new_path="$unix_path"
39349 fi
39350
39351 # remove trailing .exe if any
39352 new_path="${new_path/%.exe/}"
39353
39354 # Save the first 10 bytes of this path to the storage, so fixpath can work.
39355 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
39356 fi
39357
39358 else
39359 # We're on a posix platform. Hooray! :)
39360 # First separate the path from the arguments. This will split at the first
39361 # space.
39362 complete="$OBJDUMP"
39363 path="${complete%% *}"
39364 tmp="$complete EOL"
39365 arguments="${tmp#* }"
39366
39367 # Cannot rely on the command "which" here since it doesn't always work.
39368 is_absolute_path=`$ECHO "$path" | $GREP ^/`
39369 if test -z "$is_absolute_path"; then
39370 # Path to executable is not absolute. Find it.
39371 IFS_save="$IFS"
39372 IFS=:
39373 for p in $PATH; do
39374 if test -f "$p/$path" && test -x "$p/$path"; then
39375 new_path="$p/$path"
39376 break
39377 fi
39378 done
39379 IFS="$IFS_save"
39832
39833 # Output is in $new_path
39834
39835 windows_path="$new_path"
39836 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39837 unix_path=`$CYGPATH -u "$windows_path"`
39838 new_path="$unix_path"
39839 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39840 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39841 new_path="$unix_path"
39842 fi
39843
39844 # remove trailing .exe if any
39845 new_path="${new_path/%.exe/}"
39846
39847 # Save the first 10 bytes of this path to the storage, so fixpath can work.
39848 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
39849 fi
39850
39851 else
39852 # We're on a posix platform. Hooray! :)
39853 # First separate the path from the arguments. This will split at the first
39854 # space.
39855 complete="$BUILD_CC"
39856 path="${complete%% *}"
39857 tmp="$complete EOL"
39858 arguments="${tmp#* }"
39859
39860 # Cannot rely on the command "which" here since it doesn't always work.
39861 is_absolute_path=`$ECHO "$path" | $GREP ^/`
39862 if test -z "$is_absolute_path"; then
39863 # Path to executable is not absolute. Find it.
39864 IFS_save="$IFS"
39865 IFS=:
39866 for p in $PATH; do
39867 if test -f "$p/$path" && test -x "$p/$path"; then
39868 new_path="$p/$path"
39869 break
39870 fi
39871 done
39872 IFS="$IFS_save"
40300
40301 # Output is in $new_path
40302
40303 windows_path="$new_path"
40304 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40305 unix_path=`$CYGPATH -u "$windows_path"`
40306 new_path="$unix_path"
40307 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40308 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40309 new_path="$unix_path"
40310 fi
40311
40312 # remove trailing .exe if any
40313 new_path="${new_path/%.exe/}"
40314
40315 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40316 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40317 fi
40318
40319 else
40320 # We're on a posix platform. Hooray! :)
40321 # First separate the path from the arguments. This will split at the first
40322 # space.
40323 complete="$BUILD_CXX"
40324 path="${complete%% *}"
40325 tmp="$complete EOL"
40326 arguments="${tmp#* }"
40327
40328 # Cannot rely on the command "which" here since it doesn't always work.
40329 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40330 if test -z "$is_absolute_path"; then
40331 # Path to executable is not absolute. Find it.
40332 IFS_save="$IFS"
40333 IFS=:
40334 for p in $PATH; do
40335 if test -f "$p/$path" && test -x "$p/$path"; then
40336 new_path="$p/$path"
40337 break
40338 fi
40339 done
40340 IFS="$IFS_save"
40768
40769 # Output is in $new_path
40770
40771 windows_path="$new_path"
40772 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40773 unix_path=`$CYGPATH -u "$windows_path"`
40774 new_path="$unix_path"
40775 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40776 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40777 new_path="$unix_path"
40778 fi
40779
40780 # remove trailing .exe if any
40781 new_path="${new_path/%.exe/}"
40782
40783 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40784 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40785 fi
40786
40787 else
40788 # We're on a posix platform. Hooray! :)
40789 # First separate the path from the arguments. This will split at the first
40790 # space.
40791 complete="$BUILD_LD"
40792 path="${complete%% *}"
40793 tmp="$complete EOL"
40794 arguments="${tmp#* }"
40795
40796 # Cannot rely on the command "which" here since it doesn't always work.
40797 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40798 if test -z "$is_absolute_path"; then
40799 # Path to executable is not absolute. Find it.
40800 IFS_save="$IFS"
40801 IFS=:
40802 for p in $PATH; do
40803 if test -f "$p/$path" && test -x "$p/$path"; then
40804 new_path="$p/$path"
40805 break
40806 fi
40807 done
40808 IFS="$IFS_save"
41320
41321 windows_path="$new_path"
41322 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41323 unix_path=`$CYGPATH -u "$windows_path"`
41324 new_path="$unix_path"
41325 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41326 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
41327 new_path="$unix_path"
41328 fi
41329
41330 if test "x$path" != "x$new_path"; then
41331 JT_HOME="$new_path"
41332 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
41333 $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
41334 fi
41335
41336 # Save the first 10 bytes of this path to the storage, so fixpath can work.
41337 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
41338
41339 else
41340 # We're on a posix platform. Hooray! :)
41341 path="$JT_HOME"
41342 has_space=`$ECHO "$path" | $GREP " "`
41343 if test "x$has_space" != x; then
41344 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
41345 $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
41346 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
41347 fi
41348
41349 # Use eval to expand a potential ~
41350 eval path="$path"
41351 if test ! -f "$path" && test ! -d "$path"; then
41352 as_fn_error $? "The path of JT_HOME, which resolves as \"$path\", is not found." "$LINENO" 5
41353 fi
41354
41355 JT_HOME="`cd "$path"; $THEPWDCMD -L`"
41356 fi
41357
41358
41359 # jtreg win32 script works for everybody
41360 JTREGEXE="$JT_HOME/win32/bin/jtreg"
41848 # Always specify -m flag on Solaris
41849 # And -q on AIX because otherwise the compiler produces 32-bit objects by default
41850
41851 # When we add flags to the "official" CFLAGS etc, we need to
41852 # keep track of these additions in ADDED_CFLAGS etc. These
41853 # will later be checked to make sure only controlled additions
41854 # have been made to CFLAGS etc.
41855 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41856 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41857 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41858
41859 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
41860 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
41861 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
41862
41863 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
41864 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
41865 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
41866
41867 elif test "x$COMPILE_TYPE" = xreduced; then
41868 if test "x$OPENJDK_TARGET_OS" != xwindows; then
41869 # Specify -m if running reduced on other Posix platforms
41870
41871 # When we add flags to the "official" CFLAGS etc, we need to
41872 # keep track of these additions in ADDED_CFLAGS etc. These
41873 # will later be checked to make sure only controlled additions
41874 # have been made to CFLAGS etc.
41875 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41876 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41877 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41878
41879 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
41880 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
41881 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
41882
41883 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
41884 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
41885 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
41886
41887 fi
41888 fi
41889
42741 # Additional macosx handling
42742 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
42743 # Setting these parameters makes it an error to link to macosx APIs that are
42744 # newer than the given OS version and makes the linked binaries compatible
42745 # even if built on a newer version of the OS.
42746 # The expected format is X.Y.Z
42747 MACOSX_VERSION_MIN=10.7.0
42748
42749
42750 # The macro takes the version with no dots, ex: 1070
42751 # Let the flags variables get resolved in make for easier override on make
42752 # command line.
42753 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
42754 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
42755 fi
42756
42757 # Setup some hard coded includes
42758 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
42759 -I${JDK_TOPDIR}/src/java.base/share/native/include \
42760 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS/native/include \
42761 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_API_DIR/native/include"
42762
42763 # The shared libraries are compiled using the picflag.
42764 CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
42765 CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
42766
42767 # Executable flags
42768 CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
42769 CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
42770
42771
42772
42773
42774
42775
42776 # Setup LDFLAGS et al.
42777 #
42778
42779 # Now this is odd. The JDK native libraries have to link against libjvm.so
42780 # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
42781 # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
44677
44678 windows_path="$new_path"
44679 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44680 unix_path=`$CYGPATH -u "$windows_path"`
44681 new_path="$unix_path"
44682 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44683 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44684 new_path="$unix_path"
44685 fi
44686
44687 if test "x$path" != "x$new_path"; then
44688 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44689 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44690 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44691 fi
44692
44693 # Save the first 10 bytes of this path to the storage, so fixpath can work.
44694 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
44695
44696 else
44697 # We're on a posix platform. Hooray! :)
44698 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
44699 has_space=`$ECHO "$path" | $GREP " "`
44700 if test "x$has_space" != x; then
44701 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
44702 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
44703 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
44704 fi
44705
44706 # Use eval to expand a potential ~
44707 eval path="$path"
44708 if test ! -f "$path" && test ! -d "$path"; then
44709 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
44710 fi
44711
44712 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
44713 fi
44714
44715
44716 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44717
44799
44800 windows_path="$new_path"
44801 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44802 unix_path=`$CYGPATH -u "$windows_path"`
44803 new_path="$unix_path"
44804 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44805 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44806 new_path="$unix_path"
44807 fi
44808
44809 if test "x$path" != "x$new_path"; then
44810 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
44811 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
44812 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44813 fi
44814
44815 # Save the first 10 bytes of this path to the storage, so fixpath can work.
44816 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
44817
44818 else
44819 # We're on a posix platform. Hooray! :)
44820 path="$POTENTIAL_FREETYPE_LIB_PATH"
44821 has_space=`$ECHO "$path" | $GREP " "`
44822 if test "x$has_space" != x; then
44823 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
44824 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
44825 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
44826 fi
44827
44828 # Use eval to expand a potential ~
44829 eval path="$path"
44830 if test ! -f "$path" && test ! -d "$path"; then
44831 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
44832 fi
44833
44834 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
44835 fi
44836
44837
44838 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
44839 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
45005
45006 windows_path="$new_path"
45007 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45008 unix_path=`$CYGPATH -u "$windows_path"`
45009 new_path="$unix_path"
45010 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45011 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45012 new_path="$unix_path"
45013 fi
45014
45015 if test "x$path" != "x$new_path"; then
45016 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45017 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45018 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45019 fi
45020
45021 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45022 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45023
45024 else
45025 # We're on a posix platform. Hooray! :)
45026 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45027 has_space=`$ECHO "$path" | $GREP " "`
45028 if test "x$has_space" != x; then
45029 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
45030 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
45031 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45032 fi
45033
45034 # Use eval to expand a potential ~
45035 eval path="$path"
45036 if test ! -f "$path" && test ! -d "$path"; then
45037 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45038 fi
45039
45040 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
45041 fi
45042
45043
45044 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45045
45127
45128 windows_path="$new_path"
45129 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45130 unix_path=`$CYGPATH -u "$windows_path"`
45131 new_path="$unix_path"
45132 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45133 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45134 new_path="$unix_path"
45135 fi
45136
45137 if test "x$path" != "x$new_path"; then
45138 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45139 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45140 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45141 fi
45142
45143 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45144 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45145
45146 else
45147 # We're on a posix platform. Hooray! :)
45148 path="$POTENTIAL_FREETYPE_LIB_PATH"
45149 has_space=`$ECHO "$path" | $GREP " "`
45150 if test "x$has_space" != x; then
45151 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
45152 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
45153 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45154 fi
45155
45156 # Use eval to expand a potential ~
45157 eval path="$path"
45158 if test ! -f "$path" && test ! -d "$path"; then
45159 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45160 fi
45161
45162 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
45163 fi
45164
45165
45166 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
45594
45595 windows_path="$new_path"
45596 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45597 unix_path=`$CYGPATH -u "$windows_path"`
45598 new_path="$unix_path"
45599 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45600 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45601 new_path="$unix_path"
45602 fi
45603
45604 if test "x$path" != "x$new_path"; then
45605 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45606 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45607 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45608 fi
45609
45610 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45611 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45612
45613 else
45614 # We're on a posix platform. Hooray! :)
45615 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45616 has_space=`$ECHO "$path" | $GREP " "`
45617 if test "x$has_space" != x; then
45618 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
45619 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
45620 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45621 fi
45622
45623 # Use eval to expand a potential ~
45624 eval path="$path"
45625 if test ! -f "$path" && test ! -d "$path"; then
45626 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45627 fi
45628
45629 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
45630 fi
45631
45632
45633 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45634
45716
45717 windows_path="$new_path"
45718 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45719 unix_path=`$CYGPATH -u "$windows_path"`
45720 new_path="$unix_path"
45721 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45722 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45723 new_path="$unix_path"
45724 fi
45725
45726 if test "x$path" != "x$new_path"; then
45727 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45728 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45729 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45730 fi
45731
45732 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45733 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45734
45735 else
45736 # We're on a posix platform. Hooray! :)
45737 path="$POTENTIAL_FREETYPE_LIB_PATH"
45738 has_space=`$ECHO "$path" | $GREP " "`
45739 if test "x$has_space" != x; then
45740 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
45741 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
45742 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45743 fi
45744
45745 # Use eval to expand a potential ~
45746 eval path="$path"
45747 if test ! -f "$path" && test ! -d "$path"; then
45748 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45749 fi
45750
45751 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
45752 fi
45753
45754
45755 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45756 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
45897
45898 windows_path="$new_path"
45899 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45900 unix_path=`$CYGPATH -u "$windows_path"`
45901 new_path="$unix_path"
45902 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45903 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45904 new_path="$unix_path"
45905 fi
45906
45907 if test "x$path" != "x$new_path"; then
45908 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45909 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45910 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45911 fi
45912
45913 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45914 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45915
45916 else
45917 # We're on a posix platform. Hooray! :)
45918 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45919 has_space=`$ECHO "$path" | $GREP " "`
45920 if test "x$has_space" != x; then
45921 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
45922 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
45923 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45924 fi
45925
45926 # Use eval to expand a potential ~
45927 eval path="$path"
45928 if test ! -f "$path" && test ! -d "$path"; then
45929 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45930 fi
45931
45932 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
45933 fi
45934
45935
45936 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45937
46019
46020 windows_path="$new_path"
46021 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46022 unix_path=`$CYGPATH -u "$windows_path"`
46023 new_path="$unix_path"
46024 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46025 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46026 new_path="$unix_path"
46027 fi
46028
46029 if test "x$path" != "x$new_path"; then
46030 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46031 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46032 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46033 fi
46034
46035 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46036 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46037
46038 else
46039 # We're on a posix platform. Hooray! :)
46040 path="$POTENTIAL_FREETYPE_LIB_PATH"
46041 has_space=`$ECHO "$path" | $GREP " "`
46042 if test "x$has_space" != x; then
46043 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46044 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46045 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46046 fi
46047
46048 # Use eval to expand a potential ~
46049 eval path="$path"
46050 if test ! -f "$path" && test ! -d "$path"; then
46051 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46052 fi
46053
46054 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46055 fi
46056
46057
46058 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46059 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
46191
46192 windows_path="$new_path"
46193 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46194 unix_path=`$CYGPATH -u "$windows_path"`
46195 new_path="$unix_path"
46196 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46197 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46198 new_path="$unix_path"
46199 fi
46200
46201 if test "x$path" != "x$new_path"; then
46202 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46203 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46204 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46205 fi
46206
46207 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46208 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46209
46210 else
46211 # We're on a posix platform. Hooray! :)
46212 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46213 has_space=`$ECHO "$path" | $GREP " "`
46214 if test "x$has_space" != x; then
46215 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
46216 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
46217 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46218 fi
46219
46220 # Use eval to expand a potential ~
46221 eval path="$path"
46222 if test ! -f "$path" && test ! -d "$path"; then
46223 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46224 fi
46225
46226 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
46227 fi
46228
46229
46230 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46231
46313
46314 windows_path="$new_path"
46315 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46316 unix_path=`$CYGPATH -u "$windows_path"`
46317 new_path="$unix_path"
46318 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46319 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46320 new_path="$unix_path"
46321 fi
46322
46323 if test "x$path" != "x$new_path"; then
46324 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46325 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46326 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46327 fi
46328
46329 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46330 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46331
46332 else
46333 # We're on a posix platform. Hooray! :)
46334 path="$POTENTIAL_FREETYPE_LIB_PATH"
46335 has_space=`$ECHO "$path" | $GREP " "`
46336 if test "x$has_space" != x; then
46337 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46338 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46339 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46340 fi
46341
46342 # Use eval to expand a potential ~
46343 eval path="$path"
46344 if test ! -f "$path" && test ! -d "$path"; then
46345 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46346 fi
46347
46348 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46349 fi
46350
46351
46352 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
46485
46486 windows_path="$new_path"
46487 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46488 unix_path=`$CYGPATH -u "$windows_path"`
46489 new_path="$unix_path"
46490 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46491 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46492 new_path="$unix_path"
46493 fi
46494
46495 if test "x$path" != "x$new_path"; then
46496 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46497 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46498 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46499 fi
46500
46501 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46502 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46503
46504 else
46505 # We're on a posix platform. Hooray! :)
46506 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46507 has_space=`$ECHO "$path" | $GREP " "`
46508 if test "x$has_space" != x; then
46509 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
46510 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
46511 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46512 fi
46513
46514 # Use eval to expand a potential ~
46515 eval path="$path"
46516 if test ! -f "$path" && test ! -d "$path"; then
46517 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46518 fi
46519
46520 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
46521 fi
46522
46523
46524 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46525
46607
46608 windows_path="$new_path"
46609 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46610 unix_path=`$CYGPATH -u "$windows_path"`
46611 new_path="$unix_path"
46612 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46613 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46614 new_path="$unix_path"
46615 fi
46616
46617 if test "x$path" != "x$new_path"; then
46618 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46619 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46620 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46621 fi
46622
46623 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46624 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46625
46626 else
46627 # We're on a posix platform. Hooray! :)
46628 path="$POTENTIAL_FREETYPE_LIB_PATH"
46629 has_space=`$ECHO "$path" | $GREP " "`
46630 if test "x$has_space" != x; then
46631 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46632 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46633 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46634 fi
46635
46636 # Use eval to expand a potential ~
46637 eval path="$path"
46638 if test ! -f "$path" && test ! -d "$path"; then
46639 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46640 fi
46641
46642 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46643 fi
46644
46645
46646 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46647 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
46780
46781 windows_path="$new_path"
46782 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46783 unix_path=`$CYGPATH -u "$windows_path"`
46784 new_path="$unix_path"
46785 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46786 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46787 new_path="$unix_path"
46788 fi
46789
46790 if test "x$path" != "x$new_path"; then
46791 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46792 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46793 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46794 fi
46795
46796 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46797 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46798
46799 else
46800 # We're on a posix platform. Hooray! :)
46801 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46802 has_space=`$ECHO "$path" | $GREP " "`
46803 if test "x$has_space" != x; then
46804 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
46805 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
46806 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46807 fi
46808
46809 # Use eval to expand a potential ~
46810 eval path="$path"
46811 if test ! -f "$path" && test ! -d "$path"; then
46812 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46813 fi
46814
46815 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
46816 fi
46817
46818
46819 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46820
46902
46903 windows_path="$new_path"
46904 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46905 unix_path=`$CYGPATH -u "$windows_path"`
46906 new_path="$unix_path"
46907 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46908 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46909 new_path="$unix_path"
46910 fi
46911
46912 if test "x$path" != "x$new_path"; then
46913 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46914 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46915 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46916 fi
46917
46918 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46919 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46920
46921 else
46922 # We're on a posix platform. Hooray! :)
46923 path="$POTENTIAL_FREETYPE_LIB_PATH"
46924 has_space=`$ECHO "$path" | $GREP " "`
46925 if test "x$has_space" != x; then
46926 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46927 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46928 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46929 fi
46930
46931 # Use eval to expand a potential ~
46932 eval path="$path"
46933 if test ! -f "$path" && test ! -d "$path"; then
46934 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46935 fi
46936
46937 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46938 fi
46939
46940
46941 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46942 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47076
47077 windows_path="$new_path"
47078 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47079 unix_path=`$CYGPATH -u "$windows_path"`
47080 new_path="$unix_path"
47081 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47082 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47083 new_path="$unix_path"
47084 fi
47085
47086 if test "x$path" != "x$new_path"; then
47087 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
47088 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47089 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47090 fi
47091
47092 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47093 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47094
47095 else
47096 # We're on a posix platform. Hooray! :)
47097 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47098 has_space=`$ECHO "$path" | $GREP " "`
47099 if test "x$has_space" != x; then
47100 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47101 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47102 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47103 fi
47104
47105 # Use eval to expand a potential ~
47106 eval path="$path"
47107 if test ! -f "$path" && test ! -d "$path"; then
47108 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47109 fi
47110
47111 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47112 fi
47113
47114
47115 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47116
47198
47199 windows_path="$new_path"
47200 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47201 unix_path=`$CYGPATH -u "$windows_path"`
47202 new_path="$unix_path"
47203 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47204 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47205 new_path="$unix_path"
47206 fi
47207
47208 if test "x$path" != "x$new_path"; then
47209 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
47210 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
47211 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47212 fi
47213
47214 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47215 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47216
47217 else
47218 # We're on a posix platform. Hooray! :)
47219 path="$POTENTIAL_FREETYPE_LIB_PATH"
47220 has_space=`$ECHO "$path" | $GREP " "`
47221 if test "x$has_space" != x; then
47222 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
47223 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
47224 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47225 fi
47226
47227 # Use eval to expand a potential ~
47228 eval path="$path"
47229 if test ! -f "$path" && test ! -d "$path"; then
47230 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47231 fi
47232
47233 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
47234 fi
47235
47236
47237 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47238 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47368
47369 windows_path="$new_path"
47370 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47371 unix_path=`$CYGPATH -u "$windows_path"`
47372 new_path="$unix_path"
47373 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47374 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47375 new_path="$unix_path"
47376 fi
47377
47378 if test "x$path" != "x$new_path"; then
47379 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
47380 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47381 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47382 fi
47383
47384 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47385 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47386
47387 else
47388 # We're on a posix platform. Hooray! :)
47389 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47390 has_space=`$ECHO "$path" | $GREP " "`
47391 if test "x$has_space" != x; then
47392 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47393 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47394 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47395 fi
47396
47397 # Use eval to expand a potential ~
47398 eval path="$path"
47399 if test ! -f "$path" && test ! -d "$path"; then
47400 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47401 fi
47402
47403 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47404 fi
47405
47406
47407 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47408
47490
47491 windows_path="$new_path"
47492 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47493 unix_path=`$CYGPATH -u "$windows_path"`
47494 new_path="$unix_path"
47495 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47496 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47497 new_path="$unix_path"
47498 fi
47499
47500 if test "x$path" != "x$new_path"; then
47501 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
47502 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
47503 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47504 fi
47505
47506 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47507 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47508
47509 else
47510 # We're on a posix platform. Hooray! :)
47511 path="$POTENTIAL_FREETYPE_LIB_PATH"
47512 has_space=`$ECHO "$path" | $GREP " "`
47513 if test "x$has_space" != x; then
47514 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
47515 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
47516 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47517 fi
47518
47519 # Use eval to expand a potential ~
47520 eval path="$path"
47521 if test ! -f "$path" && test ! -d "$path"; then
47522 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47523 fi
47524
47525 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
47526 fi
47527
47528
47529 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47660
47661 windows_path="$new_path"
47662 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47663 unix_path=`$CYGPATH -u "$windows_path"`
47664 new_path="$unix_path"
47665 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47666 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47667 new_path="$unix_path"
47668 fi
47669
47670 if test "x$path" != "x$new_path"; then
47671 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
47672 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47673 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47674 fi
47675
47676 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47677 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47678
47679 else
47680 # We're on a posix platform. Hooray! :)
47681 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47682 has_space=`$ECHO "$path" | $GREP " "`
47683 if test "x$has_space" != x; then
47684 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47685 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47686 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47687 fi
47688
47689 # Use eval to expand a potential ~
47690 eval path="$path"
47691 if test ! -f "$path" && test ! -d "$path"; then
47692 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47693 fi
47694
47695 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47696 fi
47697
47698
47699 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47700
47782
47783 windows_path="$new_path"
47784 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47785 unix_path=`$CYGPATH -u "$windows_path"`
47786 new_path="$unix_path"
47787 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47788 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47789 new_path="$unix_path"
47790 fi
47791
47792 if test "x$path" != "x$new_path"; then
47793 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
47794 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
47795 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47796 fi
47797
47798 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47799 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47800
47801 else
47802 # We're on a posix platform. Hooray! :)
47803 path="$POTENTIAL_FREETYPE_LIB_PATH"
47804 has_space=`$ECHO "$path" | $GREP " "`
47805 if test "x$has_space" != x; then
47806 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
47807 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
47808 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47809 fi
47810
47811 # Use eval to expand a potential ~
47812 eval path="$path"
47813 if test ! -f "$path" && test ! -d "$path"; then
47814 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47815 fi
47816
47817 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
47818 fi
47819
47820
47821 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47822 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47960
47961 windows_path="$new_path"
47962 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47963 unix_path=`$CYGPATH -u "$windows_path"`
47964 new_path="$unix_path"
47965 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47966 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47967 new_path="$unix_path"
47968 fi
47969
47970 if test "x$path" != "x$new_path"; then
47971 FREETYPE_INCLUDE_PATH="$new_path"
47972 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47973 $as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47974 fi
47975
47976 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47977 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47978
47979 else
47980 # We're on a posix platform. Hooray! :)
47981 path="$FREETYPE_INCLUDE_PATH"
47982 has_space=`$ECHO "$path" | $GREP " "`
47983 if test "x$has_space" != x; then
47984 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47985 $as_echo "$as_me: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47986 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47987 fi
47988
47989 # Use eval to expand a potential ~
47990 eval path="$path"
47991 if test ! -f "$path" && test ! -d "$path"; then
47992 as_fn_error $? "The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47993 fi
47994
47995 FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47996 fi
47997
47998 if test -d $FREETYPE_INCLUDE_PATH/freetype2/freetype; then
47999 FREETYPE_CFLAGS="-I$FREETYPE_INCLUDE_PATH/freetype2 -I$FREETYPE_INCLUDE_PATH"
48000 else
48090
48091 windows_path="$new_path"
48092 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48093 unix_path=`$CYGPATH -u "$windows_path"`
48094 new_path="$unix_path"
48095 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48096 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48097 new_path="$unix_path"
48098 fi
48099
48100 if test "x$path" != "x$new_path"; then
48101 FREETYPE_LIB_PATH="$new_path"
48102 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
48103 $as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
48104 fi
48105
48106 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48107 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48108
48109 else
48110 # We're on a posix platform. Hooray! :)
48111 path="$FREETYPE_LIB_PATH"
48112 has_space=`$ECHO "$path" | $GREP " "`
48113 if test "x$has_space" != x; then
48114 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
48115 $as_echo "$as_me: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
48116 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48117 fi
48118
48119 # Use eval to expand a potential ~
48120 eval path="$path"
48121 if test ! -f "$path" && test ! -d "$path"; then
48122 as_fn_error $? "The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
48123 fi
48124
48125 FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
48126 fi
48127
48128 if test "x$OPENJDK_TARGET_OS" = xwindows; then
48129 FREETYPE_LIBS="$FREETYPE_LIB_PATH/freetype.lib"
48130 else
49989
49990 windows_path="$new_path"
49991 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49992 unix_path=`$CYGPATH -u "$windows_path"`
49993 new_path="$unix_path"
49994 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49995 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49996 new_path="$unix_path"
49997 fi
49998
49999 if test "x$path" != "x$new_path"; then
50000 MSVCR_DLL="$new_path"
50001 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5
50002 $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;}
50003 fi
50004
50005 # Save the first 10 bytes of this path to the storage, so fixpath can work.
50006 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
50007
50008 else
50009 # We're on a posix platform. Hooray! :)
50010 path="$MSVCR_DLL"
50011 has_space=`$ECHO "$path" | $GREP " "`
50012 if test "x$has_space" != x; then
50013 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
50014 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
50015 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50016 fi
50017
50018 # Use eval to expand a potential ~
50019 eval path="$path"
50020 if test ! -f "$path" && test ! -d "$path"; then
50021 as_fn_error $? "The path of MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50022 fi
50023
50024 MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`"
50025 fi
50026
50027
50028
50029
|
890 JVM_VARIANT_CORE
891 JVM_VARIANT_ZEROSHARK
892 JVM_VARIANT_ZERO
893 JVM_VARIANT_KERNEL
894 JVM_VARIANT_MINIMAL1
895 JVM_VARIANT_CLIENT
896 JVM_VARIANT_SERVER
897 JVM_VARIANTS
898 JVM_INTERPRETER
899 JDK_VARIANT
900 SET_OPENJDK
901 BUILD_LOG_WRAPPER
902 BUILD_LOG_PREVIOUS
903 BUILD_LOG
904 TOPDIR
905 PATH_SEP
906 ZERO_ARCHDEF
907 DEFINE_CROSS_COMPILE_ARCH
908 LP64
909 OPENJDK_TARGET_OS_EXPORT_DIR
910 OPENJDK_TARGET_CPU_JLI_CFLAGS
911 OPENJDK_TARGET_CPU_OSARCH
912 OPENJDK_TARGET_CPU_ISADIR
913 OPENJDK_TARGET_CPU_LIBDIR
914 OPENJDK_TARGET_CPU_LEGACY_LIB
915 OPENJDK_TARGET_CPU_LEGACY
916 REQUIRED_OS_VERSION
917 REQUIRED_OS_NAME
918 COMPILE_TYPE
919 OPENJDK_TARGET_CPU_ENDIAN
920 OPENJDK_TARGET_CPU_BITS
921 OPENJDK_TARGET_CPU_ARCH
922 OPENJDK_TARGET_CPU
923 OPENJDK_TARGET_OS_ENV
924 OPENJDK_TARGET_OS_TYPE
925 OPENJDK_TARGET_OS
926 OPENJDK_BUILD_CPU_ENDIAN
927 OPENJDK_BUILD_CPU_BITS
928 OPENJDK_BUILD_CPU_ARCH
929 OPENJDK_BUILD_CPU
930 OPENJDK_BUILD_OS_ENV
931 OPENJDK_BUILD_OS_TYPE
932 OPENJDK_BUILD_OS
933 OPENJDK_BUILD_AUTOCONF_NAME
934 OPENJDK_TARGET_AUTOCONF_NAME
935 target_os
936 target_vendor
937 target_cpu
938 target
939 host_os
940 host_vendor
941 host_cpu
942 host
943 build_os
944 build_vendor
945 build_cpu
946 build
947 CPIO
948 SETFILE
949 DF
950 READLINK
951 CYGPATH
3393 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3394 #
3395 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3396 # or visit www.oracle.com if you need additional information or have any
3397 # questions.
3398 #
3399
3400 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3401 # If so, then append $1 to $2 \
3402 # Also set JVM_ARG_OK to true/false depending on outcome.
3403
3404
3405 # Appends a string to a path variable, only adding the : when needed.
3406
3407
3408 # Prepends a string to a path variable, only adding the : when needed.
3409
3410
3411 # This will make sure the given variable points to a full and proper
3412 # path. This means:
3413 # 1) There will be no spaces in the path. On unix platforms,
3414 # spaces in the path will result in an error. On Windows,
3415 # the path will be rewritten using short-style to be space-free.
3416 # 2) The path will be absolute, and it will be in unix-style (on
3417 # cygwin).
3418 # $1: The name of the variable to fix
3419
3420
3421 # This will make sure the given variable points to a executable
3422 # with a full and proper path. This means:
3423 # 1) There will be no spaces in the path. On unix platforms,
3424 # spaces in the path will result in an error. On Windows,
3425 # the path will be rewritten using short-style to be space-free.
3426 # 2) The path will be absolute, and it will be in unix-style (on
3427 # cygwin).
3428 # Any arguments given to the executable is preserved.
3429 # If the input variable does not have a directory specification, then
3430 # it need to be in the PATH.
3431 # $1: The name of the variable to fix
3432
3433
3434
3435
3436 # Register a --with argument but mark it as deprecated
3437 # $1: The name of the with argument to deprecate, not including --with-
3438
3439
3440 # Register a --enable argument but mark it as deprecated
3441 # $1: The name of the with argument to deprecate, not including --enable-
3442 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3443
4309 # Check if the VS env variables were setup prior to running configure.
4310 # If not, then find vcvarsall.bat and run it automatically, and integrate
4311 # the set env variables into the spec file.
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323 # This line needs to be here, verbatim, after all includes and the dummy hook
4324 # definitions. It is replaced with custom functionality when building
4325 # custom sources.
4326 #CUSTOM_AUTOCONF_INCLUDE
4327
4328 # Do not change or remove the following line, it is needed for consistency checks:
4329 DATE_WHEN_GENERATED=1411554906
4330
4331 ###############################################################################
4332 #
4333 # Initialization / Boot-strapping
4334 #
4335 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4336 # thus it jumps back and forth, each time gaining something needed later on.
4337 #
4338 ###############################################################################
4339
4340 # If we are requested to print additional help, do that and then exit.
4341 # This must be the very first call.
4342
4343 if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4344 $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4345 $PRINTF "Which are valid to use depends on the build platform.\n"
4346 for toolchain in $VALID_TOOLCHAINS_all; do
4347 # Use indirect variable referencing
4348 toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4349 TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
13506 # to use the configure naming style.
13507
13508
13509
13510
13511
13512 # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13513 # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13514 # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13515 # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13516 OPENJDK_TARGET_AUTOCONF_NAME="$host"
13517 OPENJDK_BUILD_AUTOCONF_NAME="$build"
13518
13519
13520
13521 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13522
13523 case "$build_os" in
13524 *linux*)
13525 VAR_OS=linux
13526 VAR_OS_TYPE=unix
13527 ;;
13528 *solaris*)
13529 VAR_OS=solaris
13530 VAR_OS_TYPE=unix
13531 ;;
13532 *darwin*)
13533 VAR_OS=macosx
13534 VAR_OS_TYPE=unix
13535 ;;
13536 *bsd*)
13537 VAR_OS=bsd
13538 VAR_OS_TYPE=unix
13539 ;;
13540 *cygwin*)
13541 VAR_OS=windows
13542 VAR_OS_ENV=windows.cygwin
13543 ;;
13544 *mingw*)
13545 VAR_OS=windows
13546 VAR_OS_ENV=windows.msys
13547 ;;
13548 *aix*)
13549 VAR_OS=aix
13550 VAR_OS_TYPE=unix
13551 ;;
13552 *)
13553 as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13554 ;;
13555 esac
13556
13557
13558 # First argument is the cpu name from the trip/quad
13559 case "$build_cpu" in
13560 x86_64)
13561 VAR_CPU=x86_64
13562 VAR_CPU_ARCH=x86
13563 VAR_CPU_BITS=64
13564 VAR_CPU_ENDIAN=little
13565 ;;
13566 i?86)
13567 VAR_CPU=x86
13568 VAR_CPU_ARCH=x86
13569 VAR_CPU_BITS=32
13570 VAR_CPU_ENDIAN=little
13607 ;;
13608 sparc)
13609 VAR_CPU=sparc
13610 VAR_CPU_ARCH=sparc
13611 VAR_CPU_BITS=32
13612 VAR_CPU_ENDIAN=big
13613 ;;
13614 sparcv9|sparc64)
13615 VAR_CPU=sparcv9
13616 VAR_CPU_ARCH=sparc
13617 VAR_CPU_BITS=64
13618 VAR_CPU_ENDIAN=big
13619 ;;
13620 *)
13621 as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13622 ;;
13623 esac
13624
13625 # ..and setup our own variables. (Do this explicitely to facilitate searching)
13626 OPENJDK_BUILD_OS="$VAR_OS"
13627 if test "x$VAR_OS_TYPE" != x; then
13628 OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
13629 else
13630 OPENJDK_BUILD_OS_TYPE="$VAR_OS"
13631 fi
13632 if test "x$VAR_OS_ENV" != x; then
13633 OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13634 else
13635 OPENJDK_BUILD_OS_ENV="$VAR_OS"
13636 fi
13637 OPENJDK_BUILD_CPU="$VAR_CPU"
13638 OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13639 OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13640 OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13641
13642
13643
13644
13645
13646
13647
13648
13649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13650 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13651 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13652 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13653
13654 # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13655
13656 case "$host_os" in
13657 *linux*)
13658 VAR_OS=linux
13659 VAR_OS_TYPE=unix
13660 ;;
13661 *solaris*)
13662 VAR_OS=solaris
13663 VAR_OS_TYPE=unix
13664 ;;
13665 *darwin*)
13666 VAR_OS=macosx
13667 VAR_OS_TYPE=unix
13668 ;;
13669 *bsd*)
13670 VAR_OS=bsd
13671 VAR_OS_TYPE=unix
13672 ;;
13673 *cygwin*)
13674 VAR_OS=windows
13675 VAR_OS_ENV=windows.cygwin
13676 ;;
13677 *mingw*)
13678 VAR_OS=windows
13679 VAR_OS_ENV=windows.msys
13680 ;;
13681 *aix*)
13682 VAR_OS=aix
13683 VAR_OS_TYPE=unix
13684 ;;
13685 *)
13686 as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13687 ;;
13688 esac
13689
13690
13691 # First argument is the cpu name from the trip/quad
13692 case "$host_cpu" in
13693 x86_64)
13694 VAR_CPU=x86_64
13695 VAR_CPU_ARCH=x86
13696 VAR_CPU_BITS=64
13697 VAR_CPU_ENDIAN=little
13698 ;;
13699 i?86)
13700 VAR_CPU=x86
13701 VAR_CPU_ARCH=x86
13702 VAR_CPU_BITS=32
13703 VAR_CPU_ENDIAN=little
13740 ;;
13741 sparc)
13742 VAR_CPU=sparc
13743 VAR_CPU_ARCH=sparc
13744 VAR_CPU_BITS=32
13745 VAR_CPU_ENDIAN=big
13746 ;;
13747 sparcv9|sparc64)
13748 VAR_CPU=sparcv9
13749 VAR_CPU_ARCH=sparc
13750 VAR_CPU_BITS=64
13751 VAR_CPU_ENDIAN=big
13752 ;;
13753 *)
13754 as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13755 ;;
13756 esac
13757
13758 # ... and setup our own variables. (Do this explicitely to facilitate searching)
13759 OPENJDK_TARGET_OS="$VAR_OS"
13760 if test "x$VAR_OS_TYPE" != x; then
13761 OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
13762 else
13763 OPENJDK_TARGET_OS_TYPE="$VAR_OS"
13764 fi
13765 if test "x$VAR_OS_ENV" != x; then
13766 OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13767 else
13768 OPENJDK_TARGET_OS_ENV="$VAR_OS"
13769 fi
13770 OPENJDK_TARGET_CPU="$VAR_CPU"
13771 OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13772 OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13773 OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13774
13775
13776
13777
13778
13779
13780
13781
13782 { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13783 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13784 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13785 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13786
13787
13788
13789 # Check whether --with-target-bits was given.
13917
13918
13919 OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13920 if test "x$OPENJDK_TARGET_CPU" = xx86; then
13921 OPENJDK_TARGET_CPU_JLI="i386"
13922 elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13923 # On all platforms except macosx, we replace x86_64 with amd64.
13924 OPENJDK_TARGET_CPU_JLI="amd64"
13925 fi
13926 # Now setup the -D flags for building libjli.
13927 OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13928 if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13929 if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13930 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13931 elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13932 OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13933 fi
13934 fi
13935
13936
13937 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13938 OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13939 else
13940 OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
13941 fi
13942
13943
13944 if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13945 A_LP64="LP64:="
13946 # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13947 # unpack200.exe
13948 if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13949 ADD_LP64="-D_LP64=1"
13950 fi
13951 fi
13952 LP64=$A_LP64
13953
13954
13955 if test "x$COMPILE_TYPE" = "xcross"; then
13956 # FIXME: ... or should this include reduced builds..?
13957 DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13958 else
13959 DEFINE_CROSS_COMPILE_ARCH=""
13960 fi
14170
14171 windows_path="$new_path"
14172 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14173 unix_path=`$CYGPATH -u "$windows_path"`
14174 new_path="$unix_path"
14175 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14176 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14177 new_path="$unix_path"
14178 fi
14179
14180 if test "x$path" != "x$new_path"; then
14181 CURDIR="$new_path"
14182 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14183 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14184 fi
14185
14186 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14187 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14188
14189 else
14190 # We're on a unix platform. Hooray! :)
14191 path="$CURDIR"
14192 has_space=`$ECHO "$path" | $GREP " "`
14193 if test "x$has_space" != x; then
14194 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14195 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14196 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14197 fi
14198
14199 # Use eval to expand a potential ~
14200 eval path="$path"
14201 if test ! -f "$path" && test ! -d "$path"; then
14202 as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14203 fi
14204
14205 CURDIR="`cd "$path"; $THEPWDCMD -L`"
14206 fi
14207
14208
14209 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14210
14292
14293 windows_path="$new_path"
14294 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14295 unix_path=`$CYGPATH -u "$windows_path"`
14296 new_path="$unix_path"
14297 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14298 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14299 new_path="$unix_path"
14300 fi
14301
14302 if test "x$path" != "x$new_path"; then
14303 TOPDIR="$new_path"
14304 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14305 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14306 fi
14307
14308 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14309 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14310
14311 else
14312 # We're on a unix platform. Hooray! :)
14313 path="$TOPDIR"
14314 has_space=`$ECHO "$path" | $GREP " "`
14315 if test "x$has_space" != x; then
14316 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14317 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14318 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14319 fi
14320
14321 # Use eval to expand a potential ~
14322 eval path="$path"
14323 if test ! -f "$path" && test ! -d "$path"; then
14324 as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14325 fi
14326
14327 TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14328 fi
14329
14330 # SRC_ROOT is a traditional alias for TOPDIR.
14331 SRC_ROOT=$TOPDIR
14332
14812
14813 windows_path="$new_path"
14814 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14815 unix_path=`$CYGPATH -u "$windows_path"`
14816 new_path="$unix_path"
14817 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14818 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14819 new_path="$unix_path"
14820 fi
14821
14822 if test "x$path" != "x$new_path"; then
14823 with_devkit="$new_path"
14824 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14825 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14826 fi
14827
14828 # Save the first 10 bytes of this path to the storage, so fixpath can work.
14829 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14830
14831 else
14832 # We're on a unix platform. Hooray! :)
14833 path="$with_devkit"
14834 has_space=`$ECHO "$path" | $GREP " "`
14835 if test "x$has_space" != x; then
14836 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14837 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14838 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14839 fi
14840
14841 # Use eval to expand a potential ~
14842 eval path="$path"
14843 if test ! -f "$path" && test ! -d "$path"; then
14844 as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14845 fi
14846
14847 with_devkit="`cd "$path"; $THEPWDCMD -L`"
14848 fi
14849
14850 DEVKIT_ROOT="$with_devkit"
14851 # Check for a meta data info file in the root of the devkit
14852 if test -f "$DEVKIT_ROOT/devkit.info"; then
15286
15287 windows_path="$new_path"
15288 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15289 unix_path=`$CYGPATH -u "$windows_path"`
15290 new_path="$unix_path"
15291 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15292 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15293 new_path="$unix_path"
15294 fi
15295
15296 if test "x$path" != "x$new_path"; then
15297 OUTPUT_ROOT="$new_path"
15298 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15299 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15300 fi
15301
15302 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15303 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15304
15305 else
15306 # We're on a unix platform. Hooray! :)
15307 path="$OUTPUT_ROOT"
15308 has_space=`$ECHO "$path" | $GREP " "`
15309 if test "x$has_space" != x; then
15310 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15311 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15312 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15313 fi
15314
15315 # Use eval to expand a potential ~
15316 eval path="$path"
15317 if test ! -f "$path" && test ! -d "$path"; then
15318 as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15319 fi
15320
15321 OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15322 fi
15323
15324
15325 SPEC=$OUTPUT_ROOT/spec.gmk
15326
15659
15660 # Output is in $new_path
15661
15662 windows_path="$new_path"
15663 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15664 unix_path=`$CYGPATH -u "$windows_path"`
15665 new_path="$unix_path"
15666 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15667 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15668 new_path="$unix_path"
15669 fi
15670
15671 # remove trailing .exe if any
15672 new_path="${new_path/%.exe/}"
15673
15674 # Save the first 10 bytes of this path to the storage, so fixpath can work.
15675 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15676 fi
15677
15678 else
15679 # We're on a unix platform. Hooray! :)
15680 # First separate the path from the arguments. This will split at the first
15681 # space.
15682 complete="$FOUND_MAKE"
15683 path="${complete%% *}"
15684 tmp="$complete EOL"
15685 arguments="${tmp#* }"
15686
15687 # Cannot rely on the command "which" here since it doesn't always work.
15688 is_absolute_path=`$ECHO "$path" | $GREP ^/`
15689 if test -z "$is_absolute_path"; then
15690 # Path to executable is not absolute. Find it.
15691 IFS_save="$IFS"
15692 IFS=:
15693 for p in $PATH; do
15694 if test -f "$p/$path" && test -x "$p/$path"; then
15695 new_path="$p/$path"
15696 break
15697 fi
15698 done
15699 IFS="$IFS_save"
16032
16033 # Output is in $new_path
16034
16035 windows_path="$new_path"
16036 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16037 unix_path=`$CYGPATH -u "$windows_path"`
16038 new_path="$unix_path"
16039 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16040 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16041 new_path="$unix_path"
16042 fi
16043
16044 # remove trailing .exe if any
16045 new_path="${new_path/%.exe/}"
16046
16047 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16048 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16049 fi
16050
16051 else
16052 # We're on a unix platform. Hooray! :)
16053 # First separate the path from the arguments. This will split at the first
16054 # space.
16055 complete="$FOUND_MAKE"
16056 path="${complete%% *}"
16057 tmp="$complete EOL"
16058 arguments="${tmp#* }"
16059
16060 # Cannot rely on the command "which" here since it doesn't always work.
16061 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16062 if test -z "$is_absolute_path"; then
16063 # Path to executable is not absolute. Find it.
16064 IFS_save="$IFS"
16065 IFS=:
16066 for p in $PATH; do
16067 if test -f "$p/$path" && test -x "$p/$path"; then
16068 new_path="$p/$path"
16069 break
16070 fi
16071 done
16072 IFS="$IFS_save"
16402
16403 # Output is in $new_path
16404
16405 windows_path="$new_path"
16406 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16407 unix_path=`$CYGPATH -u "$windows_path"`
16408 new_path="$unix_path"
16409 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16410 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16411 new_path="$unix_path"
16412 fi
16413
16414 # remove trailing .exe if any
16415 new_path="${new_path/%.exe/}"
16416
16417 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16418 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16419 fi
16420
16421 else
16422 # We're on a unix platform. Hooray! :)
16423 # First separate the path from the arguments. This will split at the first
16424 # space.
16425 complete="$FOUND_MAKE"
16426 path="${complete%% *}"
16427 tmp="$complete EOL"
16428 arguments="${tmp#* }"
16429
16430 # Cannot rely on the command "which" here since it doesn't always work.
16431 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16432 if test -z "$is_absolute_path"; then
16433 # Path to executable is not absolute. Find it.
16434 IFS_save="$IFS"
16435 IFS=:
16436 for p in $PATH; do
16437 if test -f "$p/$path" && test -x "$p/$path"; then
16438 new_path="$p/$path"
16439 break
16440 fi
16441 done
16442 IFS="$IFS_save"
16777
16778 # Output is in $new_path
16779
16780 windows_path="$new_path"
16781 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16782 unix_path=`$CYGPATH -u "$windows_path"`
16783 new_path="$unix_path"
16784 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16785 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16786 new_path="$unix_path"
16787 fi
16788
16789 # remove trailing .exe if any
16790 new_path="${new_path/%.exe/}"
16791
16792 # Save the first 10 bytes of this path to the storage, so fixpath can work.
16793 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16794 fi
16795
16796 else
16797 # We're on a unix platform. Hooray! :)
16798 # First separate the path from the arguments. This will split at the first
16799 # space.
16800 complete="$FOUND_MAKE"
16801 path="${complete%% *}"
16802 tmp="$complete EOL"
16803 arguments="${tmp#* }"
16804
16805 # Cannot rely on the command "which" here since it doesn't always work.
16806 is_absolute_path=`$ECHO "$path" | $GREP ^/`
16807 if test -z "$is_absolute_path"; then
16808 # Path to executable is not absolute. Find it.
16809 IFS_save="$IFS"
16810 IFS=:
16811 for p in $PATH; do
16812 if test -f "$p/$path" && test -x "$p/$path"; then
16813 new_path="$p/$path"
16814 break
16815 fi
16816 done
16817 IFS="$IFS_save"
17146
17147 # Output is in $new_path
17148
17149 windows_path="$new_path"
17150 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17151 unix_path=`$CYGPATH -u "$windows_path"`
17152 new_path="$unix_path"
17153 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17154 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17155 new_path="$unix_path"
17156 fi
17157
17158 # remove trailing .exe if any
17159 new_path="${new_path/%.exe/}"
17160
17161 # Save the first 10 bytes of this path to the storage, so fixpath can work.
17162 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17163 fi
17164
17165 else
17166 # We're on a unix platform. Hooray! :)
17167 # First separate the path from the arguments. This will split at the first
17168 # space.
17169 complete="$FOUND_MAKE"
17170 path="${complete%% *}"
17171 tmp="$complete EOL"
17172 arguments="${tmp#* }"
17173
17174 # Cannot rely on the command "which" here since it doesn't always work.
17175 is_absolute_path=`$ECHO "$path" | $GREP ^/`
17176 if test -z "$is_absolute_path"; then
17177 # Path to executable is not absolute. Find it.
17178 IFS_save="$IFS"
17179 IFS=:
17180 for p in $PATH; do
17181 if test -f "$p/$path" && test -x "$p/$path"; then
17182 new_path="$p/$path"
17183 break
17184 fi
17185 done
17186 IFS="$IFS_save"
20301
20302 windows_path="$new_path"
20303 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20304 unix_path=`$CYGPATH -u "$windows_path"`
20305 new_path="$unix_path"
20306 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20307 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20308 new_path="$unix_path"
20309 fi
20310
20311 if test "x$path" != "x$new_path"; then
20312 BOOT_JDK="$new_path"
20313 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20314 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20315 fi
20316
20317 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20318 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20319
20320 else
20321 # We're on a unix platform. Hooray! :)
20322 path="$BOOT_JDK"
20323 has_space=`$ECHO "$path" | $GREP " "`
20324 if test "x$has_space" != x; then
20325 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20326 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20327 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20328 fi
20329
20330 # Use eval to expand a potential ~
20331 eval path="$path"
20332 if test ! -f "$path" && test ! -d "$path"; then
20333 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20334 fi
20335
20336 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20337 fi
20338
20339 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20340 $as_echo_n "checking for Boot JDK... " >&6; }
20341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20633
20634 windows_path="$new_path"
20635 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20636 unix_path=`$CYGPATH -u "$windows_path"`
20637 new_path="$unix_path"
20638 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20639 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20640 new_path="$unix_path"
20641 fi
20642
20643 if test "x$path" != "x$new_path"; then
20644 BOOT_JDK="$new_path"
20645 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20646 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20647 fi
20648
20649 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20650 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20651
20652 else
20653 # We're on a unix platform. Hooray! :)
20654 path="$BOOT_JDK"
20655 has_space=`$ECHO "$path" | $GREP " "`
20656 if test "x$has_space" != x; then
20657 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20658 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20659 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20660 fi
20661
20662 # Use eval to expand a potential ~
20663 eval path="$path"
20664 if test ! -f "$path" && test ! -d "$path"; then
20665 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20666 fi
20667
20668 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20669 fi
20670
20671 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20672 $as_echo_n "checking for Boot JDK... " >&6; }
20673 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20827
20828 windows_path="$new_path"
20829 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20830 unix_path=`$CYGPATH -u "$windows_path"`
20831 new_path="$unix_path"
20832 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20833 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20834 new_path="$unix_path"
20835 fi
20836
20837 if test "x$path" != "x$new_path"; then
20838 BOOT_JDK="$new_path"
20839 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20840 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20841 fi
20842
20843 # Save the first 10 bytes of this path to the storage, so fixpath can work.
20844 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20845
20846 else
20847 # We're on a unix platform. Hooray! :)
20848 path="$BOOT_JDK"
20849 has_space=`$ECHO "$path" | $GREP " "`
20850 if test "x$has_space" != x; then
20851 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20852 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20853 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20854 fi
20855
20856 # Use eval to expand a potential ~
20857 eval path="$path"
20858 if test ! -f "$path" && test ! -d "$path"; then
20859 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20860 fi
20861
20862 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20863 fi
20864
20865 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20866 $as_echo_n "checking for Boot JDK... " >&6; }
20867 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21014
21015 windows_path="$new_path"
21016 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21017 unix_path=`$CYGPATH -u "$windows_path"`
21018 new_path="$unix_path"
21019 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21020 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21021 new_path="$unix_path"
21022 fi
21023
21024 if test "x$path" != "x$new_path"; then
21025 BOOT_JDK="$new_path"
21026 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21027 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21028 fi
21029
21030 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21031 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21032
21033 else
21034 # We're on a unix platform. Hooray! :)
21035 path="$BOOT_JDK"
21036 has_space=`$ECHO "$path" | $GREP " "`
21037 if test "x$has_space" != x; then
21038 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21039 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21040 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21041 fi
21042
21043 # Use eval to expand a potential ~
21044 eval path="$path"
21045 if test ! -f "$path" && test ! -d "$path"; then
21046 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21047 fi
21048
21049 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21050 fi
21051
21052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21053 $as_echo_n "checking for Boot JDK... " >&6; }
21054 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21200
21201 windows_path="$new_path"
21202 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21203 unix_path=`$CYGPATH -u "$windows_path"`
21204 new_path="$unix_path"
21205 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21206 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21207 new_path="$unix_path"
21208 fi
21209
21210 if test "x$path" != "x$new_path"; then
21211 BOOT_JDK="$new_path"
21212 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21213 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21214 fi
21215
21216 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21217 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21218
21219 else
21220 # We're on a unix platform. Hooray! :)
21221 path="$BOOT_JDK"
21222 has_space=`$ECHO "$path" | $GREP " "`
21223 if test "x$has_space" != x; then
21224 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21225 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21226 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21227 fi
21228
21229 # Use eval to expand a potential ~
21230 eval path="$path"
21231 if test ! -f "$path" && test ! -d "$path"; then
21232 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21233 fi
21234
21235 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21236 fi
21237
21238 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21239 $as_echo_n "checking for Boot JDK... " >&6; }
21240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21386
21387 windows_path="$new_path"
21388 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21389 unix_path=`$CYGPATH -u "$windows_path"`
21390 new_path="$unix_path"
21391 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21392 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21393 new_path="$unix_path"
21394 fi
21395
21396 if test "x$path" != "x$new_path"; then
21397 BOOT_JDK="$new_path"
21398 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21399 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21400 fi
21401
21402 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21403 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21404
21405 else
21406 # We're on a unix platform. Hooray! :)
21407 path="$BOOT_JDK"
21408 has_space=`$ECHO "$path" | $GREP " "`
21409 if test "x$has_space" != x; then
21410 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21411 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21412 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21413 fi
21414
21415 # Use eval to expand a potential ~
21416 eval path="$path"
21417 if test ! -f "$path" && test ! -d "$path"; then
21418 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21419 fi
21420
21421 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21422 fi
21423
21424 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21425 $as_echo_n "checking for Boot JDK... " >&6; }
21426 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21563
21564 windows_path="$new_path"
21565 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21566 unix_path=`$CYGPATH -u "$windows_path"`
21567 new_path="$unix_path"
21568 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21569 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21570 new_path="$unix_path"
21571 fi
21572
21573 if test "x$path" != "x$new_path"; then
21574 BOOT_JDK="$new_path"
21575 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21576 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21577 fi
21578
21579 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21580 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21581
21582 else
21583 # We're on a unix platform. Hooray! :)
21584 path="$BOOT_JDK"
21585 has_space=`$ECHO "$path" | $GREP " "`
21586 if test "x$has_space" != x; then
21587 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21588 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21589 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21590 fi
21591
21592 # Use eval to expand a potential ~
21593 eval path="$path"
21594 if test ! -f "$path" && test ! -d "$path"; then
21595 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21596 fi
21597
21598 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21599 fi
21600
21601 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21602 $as_echo_n "checking for Boot JDK... " >&6; }
21603 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21709
21710 windows_path="$new_path"
21711 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21712 unix_path=`$CYGPATH -u "$windows_path"`
21713 new_path="$unix_path"
21714 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21715 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21716 new_path="$unix_path"
21717 fi
21718
21719 if test "x$path" != "x$new_path"; then
21720 JAVA_HOME_PROCESSED="$new_path"
21721 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21722 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21723 fi
21724
21725 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21726 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21727
21728 else
21729 # We're on a unix platform. Hooray! :)
21730 path="$JAVA_HOME_PROCESSED"
21731 has_space=`$ECHO "$path" | $GREP " "`
21732 if test "x$has_space" != x; then
21733 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21734 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21735 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21736 fi
21737
21738 # Use eval to expand a potential ~
21739 eval path="$path"
21740 if test ! -f "$path" && test ! -d "$path"; then
21741 as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21742 fi
21743
21744 JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21745 fi
21746
21747 if test ! -d "$JAVA_HOME_PROCESSED"; then
21748 { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21749 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21881
21882 windows_path="$new_path"
21883 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21884 unix_path=`$CYGPATH -u "$windows_path"`
21885 new_path="$unix_path"
21886 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21887 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21888 new_path="$unix_path"
21889 fi
21890
21891 if test "x$path" != "x$new_path"; then
21892 BOOT_JDK="$new_path"
21893 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21894 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21895 fi
21896
21897 # Save the first 10 bytes of this path to the storage, so fixpath can work.
21898 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21899
21900 else
21901 # We're on a unix platform. Hooray! :)
21902 path="$BOOT_JDK"
21903 has_space=`$ECHO "$path" | $GREP " "`
21904 if test "x$has_space" != x; then
21905 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21906 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21907 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21908 fi
21909
21910 # Use eval to expand a potential ~
21911 eval path="$path"
21912 if test ! -f "$path" && test ! -d "$path"; then
21913 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21914 fi
21915
21916 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21917 fi
21918
21919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21920 $as_echo_n "checking for Boot JDK... " >&6; }
21921 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22209
22210 windows_path="$new_path"
22211 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22212 unix_path=`$CYGPATH -u "$windows_path"`
22213 new_path="$unix_path"
22214 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22215 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22216 new_path="$unix_path"
22217 fi
22218
22219 if test "x$path" != "x$new_path"; then
22220 BOOT_JDK="$new_path"
22221 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22222 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22223 fi
22224
22225 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22226 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22227
22228 else
22229 # We're on a unix platform. Hooray! :)
22230 path="$BOOT_JDK"
22231 has_space=`$ECHO "$path" | $GREP " "`
22232 if test "x$has_space" != x; then
22233 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22234 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22235 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22236 fi
22237
22238 # Use eval to expand a potential ~
22239 eval path="$path"
22240 if test ! -f "$path" && test ! -d "$path"; then
22241 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22242 fi
22243
22244 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22245 fi
22246
22247 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22248 $as_echo_n "checking for Boot JDK... " >&6; }
22249 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22424
22425 windows_path="$new_path"
22426 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22427 unix_path=`$CYGPATH -u "$windows_path"`
22428 new_path="$unix_path"
22429 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22430 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22431 new_path="$unix_path"
22432 fi
22433
22434 if test "x$path" != "x$new_path"; then
22435 BOOT_JDK="$new_path"
22436 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22437 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22438 fi
22439
22440 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22441 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22442
22443 else
22444 # We're on a unix platform. Hooray! :)
22445 path="$BOOT_JDK"
22446 has_space=`$ECHO "$path" | $GREP " "`
22447 if test "x$has_space" != x; then
22448 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22449 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22450 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22451 fi
22452
22453 # Use eval to expand a potential ~
22454 eval path="$path"
22455 if test ! -f "$path" && test ! -d "$path"; then
22456 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22457 fi
22458
22459 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22460 fi
22461
22462 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22463 $as_echo_n "checking for Boot JDK... " >&6; }
22464 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22604
22605 windows_path="$new_path"
22606 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22607 unix_path=`$CYGPATH -u "$windows_path"`
22608 new_path="$unix_path"
22609 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22610 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22611 new_path="$unix_path"
22612 fi
22613
22614 if test "x$path" != "x$new_path"; then
22615 BOOT_JDK="$new_path"
22616 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22617 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22618 fi
22619
22620 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22621 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22622
22623 else
22624 # We're on a unix platform. Hooray! :)
22625 path="$BOOT_JDK"
22626 has_space=`$ECHO "$path" | $GREP " "`
22627 if test "x$has_space" != x; then
22628 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22629 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22630 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22631 fi
22632
22633 # Use eval to expand a potential ~
22634 eval path="$path"
22635 if test ! -f "$path" && test ! -d "$path"; then
22636 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22637 fi
22638
22639 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22640 fi
22641
22642 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22643 $as_echo_n "checking for Boot JDK... " >&6; }
22644 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22812
22813 windows_path="$new_path"
22814 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22815 unix_path=`$CYGPATH -u "$windows_path"`
22816 new_path="$unix_path"
22817 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22818 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22819 new_path="$unix_path"
22820 fi
22821
22822 if test "x$path" != "x$new_path"; then
22823 BOOT_JDK="$new_path"
22824 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22825 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22826 fi
22827
22828 # Save the first 10 bytes of this path to the storage, so fixpath can work.
22829 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22830
22831 else
22832 # We're on a unix platform. Hooray! :)
22833 path="$BOOT_JDK"
22834 has_space=`$ECHO "$path" | $GREP " "`
22835 if test "x$has_space" != x; then
22836 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22837 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22838 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22839 fi
22840
22841 # Use eval to expand a potential ~
22842 eval path="$path"
22843 if test ! -f "$path" && test ! -d "$path"; then
22844 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22845 fi
22846
22847 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22848 fi
22849
22850 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22851 $as_echo_n "checking for Boot JDK... " >&6; }
22852 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22992
22993 windows_path="$new_path"
22994 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22995 unix_path=`$CYGPATH -u "$windows_path"`
22996 new_path="$unix_path"
22997 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22998 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22999 new_path="$unix_path"
23000 fi
23001
23002 if test "x$path" != "x$new_path"; then
23003 BOOT_JDK="$new_path"
23004 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23005 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23006 fi
23007
23008 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23009 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23010
23011 else
23012 # We're on a unix platform. Hooray! :)
23013 path="$BOOT_JDK"
23014 has_space=`$ECHO "$path" | $GREP " "`
23015 if test "x$has_space" != x; then
23016 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23017 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23018 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23019 fi
23020
23021 # Use eval to expand a potential ~
23022 eval path="$path"
23023 if test ! -f "$path" && test ! -d "$path"; then
23024 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23025 fi
23026
23027 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23028 fi
23029
23030 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23031 $as_echo_n "checking for Boot JDK... " >&6; }
23032 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23200
23201 windows_path="$new_path"
23202 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23203 unix_path=`$CYGPATH -u "$windows_path"`
23204 new_path="$unix_path"
23205 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23206 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23207 new_path="$unix_path"
23208 fi
23209
23210 if test "x$path" != "x$new_path"; then
23211 BOOT_JDK="$new_path"
23212 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23213 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23214 fi
23215
23216 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23217 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23218
23219 else
23220 # We're on a unix platform. Hooray! :)
23221 path="$BOOT_JDK"
23222 has_space=`$ECHO "$path" | $GREP " "`
23223 if test "x$has_space" != x; then
23224 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23225 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23226 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23227 fi
23228
23229 # Use eval to expand a potential ~
23230 eval path="$path"
23231 if test ! -f "$path" && test ! -d "$path"; then
23232 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23233 fi
23234
23235 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23236 fi
23237
23238 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23239 $as_echo_n "checking for Boot JDK... " >&6; }
23240 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23380
23381 windows_path="$new_path"
23382 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23383 unix_path=`$CYGPATH -u "$windows_path"`
23384 new_path="$unix_path"
23385 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23386 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23387 new_path="$unix_path"
23388 fi
23389
23390 if test "x$path" != "x$new_path"; then
23391 BOOT_JDK="$new_path"
23392 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23393 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23394 fi
23395
23396 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23397 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23398
23399 else
23400 # We're on a unix platform. Hooray! :)
23401 path="$BOOT_JDK"
23402 has_space=`$ECHO "$path" | $GREP " "`
23403 if test "x$has_space" != x; then
23404 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23405 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23406 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23407 fi
23408
23409 # Use eval to expand a potential ~
23410 eval path="$path"
23411 if test ! -f "$path" && test ! -d "$path"; then
23412 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23413 fi
23414
23415 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23416 fi
23417
23418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23419 $as_echo_n "checking for Boot JDK... " >&6; }
23420 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23588
23589 windows_path="$new_path"
23590 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23591 unix_path=`$CYGPATH -u "$windows_path"`
23592 new_path="$unix_path"
23593 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23594 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23595 new_path="$unix_path"
23596 fi
23597
23598 if test "x$path" != "x$new_path"; then
23599 BOOT_JDK="$new_path"
23600 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23601 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23602 fi
23603
23604 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23605 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23606
23607 else
23608 # We're on a unix platform. Hooray! :)
23609 path="$BOOT_JDK"
23610 has_space=`$ECHO "$path" | $GREP " "`
23611 if test "x$has_space" != x; then
23612 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23613 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23614 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23615 fi
23616
23617 # Use eval to expand a potential ~
23618 eval path="$path"
23619 if test ! -f "$path" && test ! -d "$path"; then
23620 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23621 fi
23622
23623 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23624 fi
23625
23626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23627 $as_echo_n "checking for Boot JDK... " >&6; }
23628 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23768
23769 windows_path="$new_path"
23770 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23771 unix_path=`$CYGPATH -u "$windows_path"`
23772 new_path="$unix_path"
23773 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23774 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23775 new_path="$unix_path"
23776 fi
23777
23778 if test "x$path" != "x$new_path"; then
23779 BOOT_JDK="$new_path"
23780 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23781 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23782 fi
23783
23784 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23785 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23786
23787 else
23788 # We're on a unix platform. Hooray! :)
23789 path="$BOOT_JDK"
23790 has_space=`$ECHO "$path" | $GREP " "`
23791 if test "x$has_space" != x; then
23792 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23793 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23794 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23795 fi
23796
23797 # Use eval to expand a potential ~
23798 eval path="$path"
23799 if test ! -f "$path" && test ! -d "$path"; then
23800 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23801 fi
23802
23803 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23804 fi
23805
23806 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23807 $as_echo_n "checking for Boot JDK... " >&6; }
23808 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23963
23964 windows_path="$new_path"
23965 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23966 unix_path=`$CYGPATH -u "$windows_path"`
23967 new_path="$unix_path"
23968 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23969 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23970 new_path="$unix_path"
23971 fi
23972
23973 if test "x$path" != "x$new_path"; then
23974 BOOT_JDK="$new_path"
23975 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23976 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23977 fi
23978
23979 # Save the first 10 bytes of this path to the storage, so fixpath can work.
23980 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23981
23982 else
23983 # We're on a unix platform. Hooray! :)
23984 path="$BOOT_JDK"
23985 has_space=`$ECHO "$path" | $GREP " "`
23986 if test "x$has_space" != x; then
23987 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23988 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23989 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23990 fi
23991
23992 # Use eval to expand a potential ~
23993 eval path="$path"
23994 if test ! -f "$path" && test ! -d "$path"; then
23995 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23996 fi
23997
23998 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23999 fi
24000
24001 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24002 $as_echo_n "checking for Boot JDK... " >&6; }
24003 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24141
24142 windows_path="$new_path"
24143 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24144 unix_path=`$CYGPATH -u "$windows_path"`
24145 new_path="$unix_path"
24146 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24147 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24148 new_path="$unix_path"
24149 fi
24150
24151 if test "x$path" != "x$new_path"; then
24152 BOOT_JDK="$new_path"
24153 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24154 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24155 fi
24156
24157 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24158 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24159
24160 else
24161 # We're on a unix platform. Hooray! :)
24162 path="$BOOT_JDK"
24163 has_space=`$ECHO "$path" | $GREP " "`
24164 if test "x$has_space" != x; then
24165 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24166 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24167 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24168 fi
24169
24170 # Use eval to expand a potential ~
24171 eval path="$path"
24172 if test ! -f "$path" && test ! -d "$path"; then
24173 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24174 fi
24175
24176 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24177 fi
24178
24179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24180 $as_echo_n "checking for Boot JDK... " >&6; }
24181 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24337
24338 windows_path="$new_path"
24339 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24340 unix_path=`$CYGPATH -u "$windows_path"`
24341 new_path="$unix_path"
24342 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24343 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24344 new_path="$unix_path"
24345 fi
24346
24347 if test "x$path" != "x$new_path"; then
24348 BOOT_JDK="$new_path"
24349 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24350 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24351 fi
24352
24353 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24354 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24355
24356 else
24357 # We're on a unix platform. Hooray! :)
24358 path="$BOOT_JDK"
24359 has_space=`$ECHO "$path" | $GREP " "`
24360 if test "x$has_space" != x; then
24361 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24362 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24363 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24364 fi
24365
24366 # Use eval to expand a potential ~
24367 eval path="$path"
24368 if test ! -f "$path" && test ! -d "$path"; then
24369 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24370 fi
24371
24372 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24373 fi
24374
24375 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24376 $as_echo_n "checking for Boot JDK... " >&6; }
24377 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24515
24516 windows_path="$new_path"
24517 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24518 unix_path=`$CYGPATH -u "$windows_path"`
24519 new_path="$unix_path"
24520 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24521 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24522 new_path="$unix_path"
24523 fi
24524
24525 if test "x$path" != "x$new_path"; then
24526 BOOT_JDK="$new_path"
24527 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24528 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24529 fi
24530
24531 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24532 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24533
24534 else
24535 # We're on a unix platform. Hooray! :)
24536 path="$BOOT_JDK"
24537 has_space=`$ECHO "$path" | $GREP " "`
24538 if test "x$has_space" != x; then
24539 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24540 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24541 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24542 fi
24543
24544 # Use eval to expand a potential ~
24545 eval path="$path"
24546 if test ! -f "$path" && test ! -d "$path"; then
24547 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24548 fi
24549
24550 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24551 fi
24552
24553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24554 $as_echo_n "checking for Boot JDK... " >&6; }
24555 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24710
24711 windows_path="$new_path"
24712 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24713 unix_path=`$CYGPATH -u "$windows_path"`
24714 new_path="$unix_path"
24715 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24716 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24717 new_path="$unix_path"
24718 fi
24719
24720 if test "x$path" != "x$new_path"; then
24721 BOOT_JDK="$new_path"
24722 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24723 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24724 fi
24725
24726 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24727 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24728
24729 else
24730 # We're on a unix platform. Hooray! :)
24731 path="$BOOT_JDK"
24732 has_space=`$ECHO "$path" | $GREP " "`
24733 if test "x$has_space" != x; then
24734 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24735 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24736 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24737 fi
24738
24739 # Use eval to expand a potential ~
24740 eval path="$path"
24741 if test ! -f "$path" && test ! -d "$path"; then
24742 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24743 fi
24744
24745 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24746 fi
24747
24748 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24749 $as_echo_n "checking for Boot JDK... " >&6; }
24750 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24888
24889 windows_path="$new_path"
24890 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24891 unix_path=`$CYGPATH -u "$windows_path"`
24892 new_path="$unix_path"
24893 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24894 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24895 new_path="$unix_path"
24896 fi
24897
24898 if test "x$path" != "x$new_path"; then
24899 BOOT_JDK="$new_path"
24900 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24901 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24902 fi
24903
24904 # Save the first 10 bytes of this path to the storage, so fixpath can work.
24905 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24906
24907 else
24908 # We're on a unix platform. Hooray! :)
24909 path="$BOOT_JDK"
24910 has_space=`$ECHO "$path" | $GREP " "`
24911 if test "x$has_space" != x; then
24912 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24913 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24914 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24915 fi
24916
24917 # Use eval to expand a potential ~
24918 eval path="$path"
24919 if test ! -f "$path" && test ! -d "$path"; then
24920 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24921 fi
24922
24923 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24924 fi
24925
24926 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24927 $as_echo_n "checking for Boot JDK... " >&6; }
24928 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25084
25085 windows_path="$new_path"
25086 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25087 unix_path=`$CYGPATH -u "$windows_path"`
25088 new_path="$unix_path"
25089 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25090 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25091 new_path="$unix_path"
25092 fi
25093
25094 if test "x$path" != "x$new_path"; then
25095 BOOT_JDK="$new_path"
25096 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25097 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25098 fi
25099
25100 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25101 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25102
25103 else
25104 # We're on a unix platform. Hooray! :)
25105 path="$BOOT_JDK"
25106 has_space=`$ECHO "$path" | $GREP " "`
25107 if test "x$has_space" != x; then
25108 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25109 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25110 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25111 fi
25112
25113 # Use eval to expand a potential ~
25114 eval path="$path"
25115 if test ! -f "$path" && test ! -d "$path"; then
25116 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25117 fi
25118
25119 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25120 fi
25121
25122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25123 $as_echo_n "checking for Boot JDK... " >&6; }
25124 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25262
25263 windows_path="$new_path"
25264 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25265 unix_path=`$CYGPATH -u "$windows_path"`
25266 new_path="$unix_path"
25267 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25268 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25269 new_path="$unix_path"
25270 fi
25271
25272 if test "x$path" != "x$new_path"; then
25273 BOOT_JDK="$new_path"
25274 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25275 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25276 fi
25277
25278 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25279 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25280
25281 else
25282 # We're on a unix platform. Hooray! :)
25283 path="$BOOT_JDK"
25284 has_space=`$ECHO "$path" | $GREP " "`
25285 if test "x$has_space" != x; then
25286 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25287 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25288 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25289 fi
25290
25291 # Use eval to expand a potential ~
25292 eval path="$path"
25293 if test ! -f "$path" && test ! -d "$path"; then
25294 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25295 fi
25296
25297 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25298 fi
25299
25300 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25301 $as_echo_n "checking for Boot JDK... " >&6; }
25302 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
25439
25440 windows_path="$new_path"
25441 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
25442 unix_path=`$CYGPATH -u "$windows_path"`
25443 new_path="$unix_path"
25444 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
25445 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
25446 new_path="$unix_path"
25447 fi
25448
25449 if test "x$path" != "x$new_path"; then
25450 BOOT_JDK="$new_path"
25451 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
25452 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
25453 fi
25454
25455 # Save the first 10 bytes of this path to the storage, so fixpath can work.
25456 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
25457
25458 else
25459 # We're on a unix platform. Hooray! :)
25460 path="$BOOT_JDK"
25461 has_space=`$ECHO "$path" | $GREP " "`
25462 if test "x$has_space" != x; then
25463 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
25464 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
25465 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
25466 fi
25467
25468 # Use eval to expand a potential ~
25469 eval path="$path"
25470 if test ! -f "$path" && test ! -d "$path"; then
25471 as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
25472 fi
25473
25474 BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
25475 fi
25476
25477 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
25478 $as_echo_n "checking for Boot JDK... " >&6; }
25479 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
27480
27481 # Output is in $new_path
27482
27483 windows_path="$new_path"
27484 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
27485 unix_path=`$CYGPATH -u "$windows_path"`
27486 new_path="$unix_path"
27487 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
27488 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
27489 new_path="$unix_path"
27490 fi
27491
27492 # remove trailing .exe if any
27493 new_path="${new_path/%.exe/}"
27494
27495 # Save the first 10 bytes of this path to the storage, so fixpath can work.
27496 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
27497 fi
27498
27499 else
27500 # We're on a unix platform. Hooray! :)
27501 # First separate the path from the arguments. This will split at the first
27502 # space.
27503 complete="$VS_ENV_CMD"
27504 path="${complete%% *}"
27505 tmp="$complete EOL"
27506 arguments="${tmp#* }"
27507
27508 # Cannot rely on the command "which" here since it doesn't always work.
27509 is_absolute_path=`$ECHO "$path" | $GREP ^/`
27510 if test -z "$is_absolute_path"; then
27511 # Path to executable is not absolute. Find it.
27512 IFS_save="$IFS"
27513 IFS=:
27514 for p in $PATH; do
27515 if test -f "$p/$path" && test -x "$p/$path"; then
27516 new_path="$p/$path"
27517 break
27518 fi
27519 done
27520 IFS="$IFS_save"
28140
28141 # Output is in $new_path
28142
28143 windows_path="$new_path"
28144 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28145 unix_path=`$CYGPATH -u "$windows_path"`
28146 new_path="$unix_path"
28147 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28148 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28149 new_path="$unix_path"
28150 fi
28151
28152 # remove trailing .exe if any
28153 new_path="${new_path/%.exe/}"
28154
28155 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28156 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28157 fi
28158
28159 else
28160 # We're on a unix platform. Hooray! :)
28161 # First separate the path from the arguments. This will split at the first
28162 # space.
28163 complete="$CC"
28164 path="${complete%% *}"
28165 tmp="$complete EOL"
28166 arguments="${tmp#* }"
28167
28168 # Cannot rely on the command "which" here since it doesn't always work.
28169 is_absolute_path=`$ECHO "$path" | $GREP ^/`
28170 if test -z "$is_absolute_path"; then
28171 # Path to executable is not absolute. Find it.
28172 IFS_save="$IFS"
28173 IFS=:
28174 for p in $PATH; do
28175 if test -f "$p/$path" && test -x "$p/$path"; then
28176 new_path="$p/$path"
28177 break
28178 fi
28179 done
28180 IFS="$IFS_save"
28597
28598 # Output is in $new_path
28599
28600 windows_path="$new_path"
28601 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
28602 unix_path=`$CYGPATH -u "$windows_path"`
28603 new_path="$unix_path"
28604 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
28605 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
28606 new_path="$unix_path"
28607 fi
28608
28609 # remove trailing .exe if any
28610 new_path="${new_path/%.exe/}"
28611
28612 # Save the first 10 bytes of this path to the storage, so fixpath can work.
28613 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
28614 fi
28615
28616 else
28617 # We're on a unix platform. Hooray! :)
28618 # First separate the path from the arguments. This will split at the first
28619 # space.
28620 complete="$PROPER_COMPILER_CC"
28621 path="${complete%% *}"
28622 tmp="$complete EOL"
28623 arguments="${tmp#* }"
28624
28625 # Cannot rely on the command "which" here since it doesn't always work.
28626 is_absolute_path=`$ECHO "$path" | $GREP ^/`
28627 if test -z "$is_absolute_path"; then
28628 # Path to executable is not absolute. Find it.
28629 IFS_save="$IFS"
28630 IFS=:
28631 for p in $PATH; do
28632 if test -f "$p/$path" && test -x "$p/$path"; then
28633 new_path="$p/$path"
28634 break
28635 fi
28636 done
28637 IFS="$IFS_save"
29880
29881 # Output is in $new_path
29882
29883 windows_path="$new_path"
29884 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
29885 unix_path=`$CYGPATH -u "$windows_path"`
29886 new_path="$unix_path"
29887 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
29888 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
29889 new_path="$unix_path"
29890 fi
29891
29892 # remove trailing .exe if any
29893 new_path="${new_path/%.exe/}"
29894
29895 # Save the first 10 bytes of this path to the storage, so fixpath can work.
29896 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
29897 fi
29898
29899 else
29900 # We're on a unix platform. Hooray! :)
29901 # First separate the path from the arguments. This will split at the first
29902 # space.
29903 complete="$CXX"
29904 path="${complete%% *}"
29905 tmp="$complete EOL"
29906 arguments="${tmp#* }"
29907
29908 # Cannot rely on the command "which" here since it doesn't always work.
29909 is_absolute_path=`$ECHO "$path" | $GREP ^/`
29910 if test -z "$is_absolute_path"; then
29911 # Path to executable is not absolute. Find it.
29912 IFS_save="$IFS"
29913 IFS=:
29914 for p in $PATH; do
29915 if test -f "$p/$path" && test -x "$p/$path"; then
29916 new_path="$p/$path"
29917 break
29918 fi
29919 done
29920 IFS="$IFS_save"
30337
30338 # Output is in $new_path
30339
30340 windows_path="$new_path"
30341 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
30342 unix_path=`$CYGPATH -u "$windows_path"`
30343 new_path="$unix_path"
30344 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
30345 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
30346 new_path="$unix_path"
30347 fi
30348
30349 # remove trailing .exe if any
30350 new_path="${new_path/%.exe/}"
30351
30352 # Save the first 10 bytes of this path to the storage, so fixpath can work.
30353 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
30354 fi
30355
30356 else
30357 # We're on a unix platform. Hooray! :)
30358 # First separate the path from the arguments. This will split at the first
30359 # space.
30360 complete="$PROPER_COMPILER_CXX"
30361 path="${complete%% *}"
30362 tmp="$complete EOL"
30363 arguments="${tmp#* }"
30364
30365 # Cannot rely on the command "which" here since it doesn't always work.
30366 is_absolute_path=`$ECHO "$path" | $GREP ^/`
30367 if test -z "$is_absolute_path"; then
30368 # Path to executable is not absolute. Find it.
30369 IFS_save="$IFS"
30370 IFS=:
30371 for p in $PATH; do
30372 if test -f "$p/$path" && test -x "$p/$path"; then
30373 new_path="$p/$path"
30374 break
30375 fi
30376 done
30377 IFS="$IFS_save"
31199
31200 # Output is in $new_path
31201
31202 windows_path="$new_path"
31203 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31204 unix_path=`$CYGPATH -u "$windows_path"`
31205 new_path="$unix_path"
31206 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31207 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31208 new_path="$unix_path"
31209 fi
31210
31211 # remove trailing .exe if any
31212 new_path="${new_path/%.exe/}"
31213
31214 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31215 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31216 fi
31217
31218 else
31219 # We're on a unix platform. Hooray! :)
31220 # First separate the path from the arguments. This will split at the first
31221 # space.
31222 complete="$CPP"
31223 path="${complete%% *}"
31224 tmp="$complete EOL"
31225 arguments="${tmp#* }"
31226
31227 # Cannot rely on the command "which" here since it doesn't always work.
31228 is_absolute_path=`$ECHO "$path" | $GREP ^/`
31229 if test -z "$is_absolute_path"; then
31230 # Path to executable is not absolute. Find it.
31231 IFS_save="$IFS"
31232 IFS=:
31233 for p in $PATH; do
31234 if test -f "$p/$path" && test -x "$p/$path"; then
31235 new_path="$p/$path"
31236 break
31237 fi
31238 done
31239 IFS="$IFS_save"
31614
31615 # Output is in $new_path
31616
31617 windows_path="$new_path"
31618 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31619 unix_path=`$CYGPATH -u "$windows_path"`
31620 new_path="$unix_path"
31621 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31622 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31623 new_path="$unix_path"
31624 fi
31625
31626 # remove trailing .exe if any
31627 new_path="${new_path/%.exe/}"
31628
31629 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31630 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31631 fi
31632
31633 else
31634 # We're on a unix platform. Hooray! :)
31635 # First separate the path from the arguments. This will split at the first
31636 # space.
31637 complete="$CXXCPP"
31638 path="${complete%% *}"
31639 tmp="$complete EOL"
31640 arguments="${tmp#* }"
31641
31642 # Cannot rely on the command "which" here since it doesn't always work.
31643 is_absolute_path=`$ECHO "$path" | $GREP ^/`
31644 if test -z "$is_absolute_path"; then
31645 # Path to executable is not absolute. Find it.
31646 IFS_save="$IFS"
31647 IFS=:
31648 for p in $PATH; do
31649 if test -f "$p/$path" && test -x "$p/$path"; then
31650 new_path="$p/$path"
31651 break
31652 fi
31653 done
31654 IFS="$IFS_save"
31958
31959 # Output is in $new_path
31960
31961 windows_path="$new_path"
31962 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
31963 unix_path=`$CYGPATH -u "$windows_path"`
31964 new_path="$unix_path"
31965 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
31966 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
31967 new_path="$unix_path"
31968 fi
31969
31970 # remove trailing .exe if any
31971 new_path="${new_path/%.exe/}"
31972
31973 # Save the first 10 bytes of this path to the storage, so fixpath can work.
31974 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
31975 fi
31976
31977 else
31978 # We're on a unix platform. Hooray! :)
31979 # First separate the path from the arguments. This will split at the first
31980 # space.
31981 complete="$LD"
31982 path="${complete%% *}"
31983 tmp="$complete EOL"
31984 arguments="${tmp#* }"
31985
31986 # Cannot rely on the command "which" here since it doesn't always work.
31987 is_absolute_path=`$ECHO "$path" | $GREP ^/`
31988 if test -z "$is_absolute_path"; then
31989 # Path to executable is not absolute. Find it.
31990 IFS_save="$IFS"
31991 IFS=:
31992 for p in $PATH; do
31993 if test -f "$p/$path" && test -x "$p/$path"; then
31994 new_path="$p/$path"
31995 break
31996 fi
31997 done
31998 IFS="$IFS_save"
32453
32454 # Output is in $new_path
32455
32456 windows_path="$new_path"
32457 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
32458 unix_path=`$CYGPATH -u "$windows_path"`
32459 new_path="$unix_path"
32460 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
32461 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
32462 new_path="$unix_path"
32463 fi
32464
32465 # remove trailing .exe if any
32466 new_path="${new_path/%.exe/}"
32467
32468 # Save the first 10 bytes of this path to the storage, so fixpath can work.
32469 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
32470 fi
32471
32472 else
32473 # We're on a unix platform. Hooray! :)
32474 # First separate the path from the arguments. This will split at the first
32475 # space.
32476 complete="$AS"
32477 path="${complete%% *}"
32478 tmp="$complete EOL"
32479 arguments="${tmp#* }"
32480
32481 # Cannot rely on the command "which" here since it doesn't always work.
32482 is_absolute_path=`$ECHO "$path" | $GREP ^/`
32483 if test -z "$is_absolute_path"; then
32484 # Path to executable is not absolute. Find it.
32485 IFS_save="$IFS"
32486 IFS=:
32487 for p in $PATH; do
32488 if test -f "$p/$path" && test -x "$p/$path"; then
32489 new_path="$p/$path"
32490 break
32491 fi
32492 done
32493 IFS="$IFS_save"
33081
33082 # Output is in $new_path
33083
33084 windows_path="$new_path"
33085 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33086 unix_path=`$CYGPATH -u "$windows_path"`
33087 new_path="$unix_path"
33088 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33089 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33090 new_path="$unix_path"
33091 fi
33092
33093 # remove trailing .exe if any
33094 new_path="${new_path/%.exe/}"
33095
33096 # Save the first 10 bytes of this path to the storage, so fixpath can work.
33097 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
33098 fi
33099
33100 else
33101 # We're on a unix platform. Hooray! :)
33102 # First separate the path from the arguments. This will split at the first
33103 # space.
33104 complete="$AR"
33105 path="${complete%% *}"
33106 tmp="$complete EOL"
33107 arguments="${tmp#* }"
33108
33109 # Cannot rely on the command "which" here since it doesn't always work.
33110 is_absolute_path=`$ECHO "$path" | $GREP ^/`
33111 if test -z "$is_absolute_path"; then
33112 # Path to executable is not absolute. Find it.
33113 IFS_save="$IFS"
33114 IFS=:
33115 for p in $PATH; do
33116 if test -f "$p/$path" && test -x "$p/$path"; then
33117 new_path="$p/$path"
33118 break
33119 fi
33120 done
33121 IFS="$IFS_save"
33617
33618 # Output is in $new_path
33619
33620 windows_path="$new_path"
33621 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
33622 unix_path=`$CYGPATH -u "$windows_path"`
33623 new_path="$unix_path"
33624 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
33625 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
33626 new_path="$unix_path"
33627 fi
33628
33629 # remove trailing .exe if any
33630 new_path="${new_path/%.exe/}"
33631
33632 # Save the first 10 bytes of this path to the storage, so fixpath can work.
33633 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
33634 fi
33635
33636 else
33637 # We're on a unix platform. Hooray! :)
33638 # First separate the path from the arguments. This will split at the first
33639 # space.
33640 complete="$OBJC"
33641 path="${complete%% *}"
33642 tmp="$complete EOL"
33643 arguments="${tmp#* }"
33644
33645 # Cannot rely on the command "which" here since it doesn't always work.
33646 is_absolute_path=`$ECHO "$path" | $GREP ^/`
33647 if test -z "$is_absolute_path"; then
33648 # Path to executable is not absolute. Find it.
33649 IFS_save="$IFS"
33650 IFS=:
33651 for p in $PATH; do
33652 if test -f "$p/$path" && test -x "$p/$path"; then
33653 new_path="$p/$path"
33654 break
33655 fi
33656 done
33657 IFS="$IFS_save"
34085
34086 # Output is in $new_path
34087
34088 windows_path="$new_path"
34089 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34090 unix_path=`$CYGPATH -u "$windows_path"`
34091 new_path="$unix_path"
34092 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34093 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34094 new_path="$unix_path"
34095 fi
34096
34097 # remove trailing .exe if any
34098 new_path="${new_path/%.exe/}"
34099
34100 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34101 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34102 fi
34103
34104 else
34105 # We're on a unix platform. Hooray! :)
34106 # First separate the path from the arguments. This will split at the first
34107 # space.
34108 complete="$LIPO"
34109 path="${complete%% *}"
34110 tmp="$complete EOL"
34111 arguments="${tmp#* }"
34112
34113 # Cannot rely on the command "which" here since it doesn't always work.
34114 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34115 if test -z "$is_absolute_path"; then
34116 # Path to executable is not absolute. Find it.
34117 IFS_save="$IFS"
34118 IFS=:
34119 for p in $PATH; do
34120 if test -f "$p/$path" && test -x "$p/$path"; then
34121 new_path="$p/$path"
34122 break
34123 fi
34124 done
34125 IFS="$IFS_save"
34426
34427 # Output is in $new_path
34428
34429 windows_path="$new_path"
34430 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34431 unix_path=`$CYGPATH -u "$windows_path"`
34432 new_path="$unix_path"
34433 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34434 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34435 new_path="$unix_path"
34436 fi
34437
34438 # remove trailing .exe if any
34439 new_path="${new_path/%.exe/}"
34440
34441 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34442 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34443 fi
34444
34445 else
34446 # We're on a unix platform. Hooray! :)
34447 # First separate the path from the arguments. This will split at the first
34448 # space.
34449 complete="$MT"
34450 path="${complete%% *}"
34451 tmp="$complete EOL"
34452 arguments="${tmp#* }"
34453
34454 # Cannot rely on the command "which" here since it doesn't always work.
34455 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34456 if test -z "$is_absolute_path"; then
34457 # Path to executable is not absolute. Find it.
34458 IFS_save="$IFS"
34459 IFS=:
34460 for p in $PATH; do
34461 if test -f "$p/$path" && test -x "$p/$path"; then
34462 new_path="$p/$path"
34463 break
34464 fi
34465 done
34466 IFS="$IFS_save"
34763
34764 # Output is in $new_path
34765
34766 windows_path="$new_path"
34767 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
34768 unix_path=`$CYGPATH -u "$windows_path"`
34769 new_path="$unix_path"
34770 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
34771 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
34772 new_path="$unix_path"
34773 fi
34774
34775 # remove trailing .exe if any
34776 new_path="${new_path/%.exe/}"
34777
34778 # Save the first 10 bytes of this path to the storage, so fixpath can work.
34779 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
34780 fi
34781
34782 else
34783 # We're on a unix platform. Hooray! :)
34784 # First separate the path from the arguments. This will split at the first
34785 # space.
34786 complete="$RC"
34787 path="${complete%% *}"
34788 tmp="$complete EOL"
34789 arguments="${tmp#* }"
34790
34791 # Cannot rely on the command "which" here since it doesn't always work.
34792 is_absolute_path=`$ECHO "$path" | $GREP ^/`
34793 if test -z "$is_absolute_path"; then
34794 # Path to executable is not absolute. Find it.
34795 IFS_save="$IFS"
34796 IFS=:
34797 for p in $PATH; do
34798 if test -f "$p/$path" && test -x "$p/$path"; then
34799 new_path="$p/$path"
34800 break
34801 fi
34802 done
34803 IFS="$IFS_save"
35082
35083 # Output is in $new_path
35084
35085 windows_path="$new_path"
35086 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35087 unix_path=`$CYGPATH -u "$windows_path"`
35088 new_path="$unix_path"
35089 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35090 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35091 new_path="$unix_path"
35092 fi
35093
35094 # remove trailing .exe if any
35095 new_path="${new_path/%.exe/}"
35096
35097 # Save the first 10 bytes of this path to the storage, so fixpath can work.
35098 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
35099 fi
35100
35101 else
35102 # We're on a unix platform. Hooray! :)
35103 # First separate the path from the arguments. This will split at the first
35104 # space.
35105 complete="$DUMPBIN"
35106 path="${complete%% *}"
35107 tmp="$complete EOL"
35108 arguments="${tmp#* }"
35109
35110 # Cannot rely on the command "which" here since it doesn't always work.
35111 is_absolute_path=`$ECHO "$path" | $GREP ^/`
35112 if test -z "$is_absolute_path"; then
35113 # Path to executable is not absolute. Find it.
35114 IFS_save="$IFS"
35115 IFS=:
35116 for p in $PATH; do
35117 if test -f "$p/$path" && test -x "$p/$path"; then
35118 new_path="$p/$path"
35119 break
35120 fi
35121 done
35122 IFS="$IFS_save"
35597
35598 # Output is in $new_path
35599
35600 windows_path="$new_path"
35601 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
35602 unix_path=`$CYGPATH -u "$windows_path"`
35603 new_path="$unix_path"
35604 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
35605 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
35606 new_path="$unix_path"
35607 fi
35608
35609 # remove trailing .exe if any
35610 new_path="${new_path/%.exe/}"
35611
35612 # Save the first 10 bytes of this path to the storage, so fixpath can work.
35613 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
35614 fi
35615
35616 else
35617 # We're on a unix platform. Hooray! :)
35618 # First separate the path from the arguments. This will split at the first
35619 # space.
35620 complete="$STRIP"
35621 path="${complete%% *}"
35622 tmp="$complete EOL"
35623 arguments="${tmp#* }"
35624
35625 # Cannot rely on the command "which" here since it doesn't always work.
35626 is_absolute_path=`$ECHO "$path" | $GREP ^/`
35627 if test -z "$is_absolute_path"; then
35628 # Path to executable is not absolute. Find it.
35629 IFS_save="$IFS"
35630 IFS=:
35631 for p in $PATH; do
35632 if test -f "$p/$path" && test -x "$p/$path"; then
35633 new_path="$p/$path"
35634 break
35635 fi
35636 done
35637 IFS="$IFS_save"
36065
36066 # Output is in $new_path
36067
36068 windows_path="$new_path"
36069 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36070 unix_path=`$CYGPATH -u "$windows_path"`
36071 new_path="$unix_path"
36072 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36073 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36074 new_path="$unix_path"
36075 fi
36076
36077 # remove trailing .exe if any
36078 new_path="${new_path/%.exe/}"
36079
36080 # Save the first 10 bytes of this path to the storage, so fixpath can work.
36081 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
36082 fi
36083
36084 else
36085 # We're on a unix platform. Hooray! :)
36086 # First separate the path from the arguments. This will split at the first
36087 # space.
36088 complete="$NM"
36089 path="${complete%% *}"
36090 tmp="$complete EOL"
36091 arguments="${tmp#* }"
36092
36093 # Cannot rely on the command "which" here since it doesn't always work.
36094 is_absolute_path=`$ECHO "$path" | $GREP ^/`
36095 if test -z "$is_absolute_path"; then
36096 # Path to executable is not absolute. Find it.
36097 IFS_save="$IFS"
36098 IFS=:
36099 for p in $PATH; do
36100 if test -f "$p/$path" && test -x "$p/$path"; then
36101 new_path="$p/$path"
36102 break
36103 fi
36104 done
36105 IFS="$IFS_save"
36533
36534 # Output is in $new_path
36535
36536 windows_path="$new_path"
36537 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
36538 unix_path=`$CYGPATH -u "$windows_path"`
36539 new_path="$unix_path"
36540 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
36541 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
36542 new_path="$unix_path"
36543 fi
36544
36545 # remove trailing .exe if any
36546 new_path="${new_path/%.exe/}"
36547
36548 # Save the first 10 bytes of this path to the storage, so fixpath can work.
36549 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
36550 fi
36551
36552 else
36553 # We're on a unix platform. Hooray! :)
36554 # First separate the path from the arguments. This will split at the first
36555 # space.
36556 complete="$GNM"
36557 path="${complete%% *}"
36558 tmp="$complete EOL"
36559 arguments="${tmp#* }"
36560
36561 # Cannot rely on the command "which" here since it doesn't always work.
36562 is_absolute_path=`$ECHO "$path" | $GREP ^/`
36563 if test -z "$is_absolute_path"; then
36564 # Path to executable is not absolute. Find it.
36565 IFS_save="$IFS"
36566 IFS=:
36567 for p in $PATH; do
36568 if test -f "$p/$path" && test -x "$p/$path"; then
36569 new_path="$p/$path"
36570 break
36571 fi
36572 done
36573 IFS="$IFS_save"
37002
37003 # Output is in $new_path
37004
37005 windows_path="$new_path"
37006 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37007 unix_path=`$CYGPATH -u "$windows_path"`
37008 new_path="$unix_path"
37009 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37010 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37011 new_path="$unix_path"
37012 fi
37013
37014 # remove trailing .exe if any
37015 new_path="${new_path/%.exe/}"
37016
37017 # Save the first 10 bytes of this path to the storage, so fixpath can work.
37018 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
37019 fi
37020
37021 else
37022 # We're on a unix platform. Hooray! :)
37023 # First separate the path from the arguments. This will split at the first
37024 # space.
37025 complete="$MCS"
37026 path="${complete%% *}"
37027 tmp="$complete EOL"
37028 arguments="${tmp#* }"
37029
37030 # Cannot rely on the command "which" here since it doesn't always work.
37031 is_absolute_path=`$ECHO "$path" | $GREP ^/`
37032 if test -z "$is_absolute_path"; then
37033 # Path to executable is not absolute. Find it.
37034 IFS_save="$IFS"
37035 IFS=:
37036 for p in $PATH; do
37037 if test -f "$p/$path" && test -x "$p/$path"; then
37038 new_path="$p/$path"
37039 break
37040 fi
37041 done
37042 IFS="$IFS_save"
37582
37583 # Output is in $new_path
37584
37585 windows_path="$new_path"
37586 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
37587 unix_path=`$CYGPATH -u "$windows_path"`
37588 new_path="$unix_path"
37589 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
37590 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
37591 new_path="$unix_path"
37592 fi
37593
37594 # remove trailing .exe if any
37595 new_path="${new_path/%.exe/}"
37596
37597 # Save the first 10 bytes of this path to the storage, so fixpath can work.
37598 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
37599 fi
37600
37601 else
37602 # We're on a unix platform. Hooray! :)
37603 # First separate the path from the arguments. This will split at the first
37604 # space.
37605 complete="$STRIP"
37606 path="${complete%% *}"
37607 tmp="$complete EOL"
37608 arguments="${tmp#* }"
37609
37610 # Cannot rely on the command "which" here since it doesn't always work.
37611 is_absolute_path=`$ECHO "$path" | $GREP ^/`
37612 if test -z "$is_absolute_path"; then
37613 # Path to executable is not absolute. Find it.
37614 IFS_save="$IFS"
37615 IFS=:
37616 for p in $PATH; do
37617 if test -f "$p/$path" && test -x "$p/$path"; then
37618 new_path="$p/$path"
37619 break
37620 fi
37621 done
37622 IFS="$IFS_save"
38160
38161 # Output is in $new_path
38162
38163 windows_path="$new_path"
38164 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38165 unix_path=`$CYGPATH -u "$windows_path"`
38166 new_path="$unix_path"
38167 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38168 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38169 new_path="$unix_path"
38170 fi
38171
38172 # remove trailing .exe if any
38173 new_path="${new_path/%.exe/}"
38174
38175 # Save the first 10 bytes of this path to the storage, so fixpath can work.
38176 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
38177 fi
38178
38179 else
38180 # We're on a unix platform. Hooray! :)
38181 # First separate the path from the arguments. This will split at the first
38182 # space.
38183 complete="$NM"
38184 path="${complete%% *}"
38185 tmp="$complete EOL"
38186 arguments="${tmp#* }"
38187
38188 # Cannot rely on the command "which" here since it doesn't always work.
38189 is_absolute_path=`$ECHO "$path" | $GREP ^/`
38190 if test -z "$is_absolute_path"; then
38191 # Path to executable is not absolute. Find it.
38192 IFS_save="$IFS"
38193 IFS=:
38194 for p in $PATH; do
38195 if test -f "$p/$path" && test -x "$p/$path"; then
38196 new_path="$p/$path"
38197 break
38198 fi
38199 done
38200 IFS="$IFS_save"
38747
38748 # Output is in $new_path
38749
38750 windows_path="$new_path"
38751 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
38752 unix_path=`$CYGPATH -u "$windows_path"`
38753 new_path="$unix_path"
38754 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
38755 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
38756 new_path="$unix_path"
38757 fi
38758
38759 # remove trailing .exe if any
38760 new_path="${new_path/%.exe/}"
38761
38762 # Save the first 10 bytes of this path to the storage, so fixpath can work.
38763 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
38764 fi
38765
38766 else
38767 # We're on a unix platform. Hooray! :)
38768 # First separate the path from the arguments. This will split at the first
38769 # space.
38770 complete="$OBJCOPY"
38771 path="${complete%% *}"
38772 tmp="$complete EOL"
38773 arguments="${tmp#* }"
38774
38775 # Cannot rely on the command "which" here since it doesn't always work.
38776 is_absolute_path=`$ECHO "$path" | $GREP ^/`
38777 if test -z "$is_absolute_path"; then
38778 # Path to executable is not absolute. Find it.
38779 IFS_save="$IFS"
38780 IFS=:
38781 for p in $PATH; do
38782 if test -f "$p/$path" && test -x "$p/$path"; then
38783 new_path="$p/$path"
38784 break
38785 fi
38786 done
38787 IFS="$IFS_save"
39331
39332 # Output is in $new_path
39333
39334 windows_path="$new_path"
39335 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39336 unix_path=`$CYGPATH -u "$windows_path"`
39337 new_path="$unix_path"
39338 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39339 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39340 new_path="$unix_path"
39341 fi
39342
39343 # remove trailing .exe if any
39344 new_path="${new_path/%.exe/}"
39345
39346 # Save the first 10 bytes of this path to the storage, so fixpath can work.
39347 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
39348 fi
39349
39350 else
39351 # We're on a unix platform. Hooray! :)
39352 # First separate the path from the arguments. This will split at the first
39353 # space.
39354 complete="$OBJDUMP"
39355 path="${complete%% *}"
39356 tmp="$complete EOL"
39357 arguments="${tmp#* }"
39358
39359 # Cannot rely on the command "which" here since it doesn't always work.
39360 is_absolute_path=`$ECHO "$path" | $GREP ^/`
39361 if test -z "$is_absolute_path"; then
39362 # Path to executable is not absolute. Find it.
39363 IFS_save="$IFS"
39364 IFS=:
39365 for p in $PATH; do
39366 if test -f "$p/$path" && test -x "$p/$path"; then
39367 new_path="$p/$path"
39368 break
39369 fi
39370 done
39371 IFS="$IFS_save"
39824
39825 # Output is in $new_path
39826
39827 windows_path="$new_path"
39828 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
39829 unix_path=`$CYGPATH -u "$windows_path"`
39830 new_path="$unix_path"
39831 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
39832 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
39833 new_path="$unix_path"
39834 fi
39835
39836 # remove trailing .exe if any
39837 new_path="${new_path/%.exe/}"
39838
39839 # Save the first 10 bytes of this path to the storage, so fixpath can work.
39840 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
39841 fi
39842
39843 else
39844 # We're on a unix platform. Hooray! :)
39845 # First separate the path from the arguments. This will split at the first
39846 # space.
39847 complete="$BUILD_CC"
39848 path="${complete%% *}"
39849 tmp="$complete EOL"
39850 arguments="${tmp#* }"
39851
39852 # Cannot rely on the command "which" here since it doesn't always work.
39853 is_absolute_path=`$ECHO "$path" | $GREP ^/`
39854 if test -z "$is_absolute_path"; then
39855 # Path to executable is not absolute. Find it.
39856 IFS_save="$IFS"
39857 IFS=:
39858 for p in $PATH; do
39859 if test -f "$p/$path" && test -x "$p/$path"; then
39860 new_path="$p/$path"
39861 break
39862 fi
39863 done
39864 IFS="$IFS_save"
40292
40293 # Output is in $new_path
40294
40295 windows_path="$new_path"
40296 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40297 unix_path=`$CYGPATH -u "$windows_path"`
40298 new_path="$unix_path"
40299 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40300 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40301 new_path="$unix_path"
40302 fi
40303
40304 # remove trailing .exe if any
40305 new_path="${new_path/%.exe/}"
40306
40307 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40308 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40309 fi
40310
40311 else
40312 # We're on a unix platform. Hooray! :)
40313 # First separate the path from the arguments. This will split at the first
40314 # space.
40315 complete="$BUILD_CXX"
40316 path="${complete%% *}"
40317 tmp="$complete EOL"
40318 arguments="${tmp#* }"
40319
40320 # Cannot rely on the command "which" here since it doesn't always work.
40321 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40322 if test -z "$is_absolute_path"; then
40323 # Path to executable is not absolute. Find it.
40324 IFS_save="$IFS"
40325 IFS=:
40326 for p in $PATH; do
40327 if test -f "$p/$path" && test -x "$p/$path"; then
40328 new_path="$p/$path"
40329 break
40330 fi
40331 done
40332 IFS="$IFS_save"
40760
40761 # Output is in $new_path
40762
40763 windows_path="$new_path"
40764 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
40765 unix_path=`$CYGPATH -u "$windows_path"`
40766 new_path="$unix_path"
40767 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
40768 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
40769 new_path="$unix_path"
40770 fi
40771
40772 # remove trailing .exe if any
40773 new_path="${new_path/%.exe/}"
40774
40775 # Save the first 10 bytes of this path to the storage, so fixpath can work.
40776 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
40777 fi
40778
40779 else
40780 # We're on a unix platform. Hooray! :)
40781 # First separate the path from the arguments. This will split at the first
40782 # space.
40783 complete="$BUILD_LD"
40784 path="${complete%% *}"
40785 tmp="$complete EOL"
40786 arguments="${tmp#* }"
40787
40788 # Cannot rely on the command "which" here since it doesn't always work.
40789 is_absolute_path=`$ECHO "$path" | $GREP ^/`
40790 if test -z "$is_absolute_path"; then
40791 # Path to executable is not absolute. Find it.
40792 IFS_save="$IFS"
40793 IFS=:
40794 for p in $PATH; do
40795 if test -f "$p/$path" && test -x "$p/$path"; then
40796 new_path="$p/$path"
40797 break
40798 fi
40799 done
40800 IFS="$IFS_save"
41312
41313 windows_path="$new_path"
41314 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
41315 unix_path=`$CYGPATH -u "$windows_path"`
41316 new_path="$unix_path"
41317 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
41318 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
41319 new_path="$unix_path"
41320 fi
41321
41322 if test "x$path" != "x$new_path"; then
41323 JT_HOME="$new_path"
41324 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
41325 $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
41326 fi
41327
41328 # Save the first 10 bytes of this path to the storage, so fixpath can work.
41329 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
41330
41331 else
41332 # We're on a unix platform. Hooray! :)
41333 path="$JT_HOME"
41334 has_space=`$ECHO "$path" | $GREP " "`
41335 if test "x$has_space" != x; then
41336 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
41337 $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
41338 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
41339 fi
41340
41341 # Use eval to expand a potential ~
41342 eval path="$path"
41343 if test ! -f "$path" && test ! -d "$path"; then
41344 as_fn_error $? "The path of JT_HOME, which resolves as \"$path\", is not found." "$LINENO" 5
41345 fi
41346
41347 JT_HOME="`cd "$path"; $THEPWDCMD -L`"
41348 fi
41349
41350
41351 # jtreg win32 script works for everybody
41352 JTREGEXE="$JT_HOME/win32/bin/jtreg"
41840 # Always specify -m flag on Solaris
41841 # And -q on AIX because otherwise the compiler produces 32-bit objects by default
41842
41843 # When we add flags to the "official" CFLAGS etc, we need to
41844 # keep track of these additions in ADDED_CFLAGS etc. These
41845 # will later be checked to make sure only controlled additions
41846 # have been made to CFLAGS etc.
41847 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41848 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41849 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41850
41851 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
41852 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
41853 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
41854
41855 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
41856 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
41857 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
41858
41859 elif test "x$COMPILE_TYPE" = xreduced; then
41860 if test "x$OPENJDK_TARGET_OS_TYPE" = xunix; then
41861 # Specify -m if running reduced on unix platforms
41862
41863 # When we add flags to the "official" CFLAGS etc, we need to
41864 # keep track of these additions in ADDED_CFLAGS etc. These
41865 # will later be checked to make sure only controlled additions
41866 # have been made to CFLAGS etc.
41867 ADDED_CFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41868 ADDED_CXXFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41869 ADDED_LDFLAGS=" ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
41870
41871 CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
41872 CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
41873 LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
41874
41875 CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
41876 CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
41877 LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
41878
41879 fi
41880 fi
41881
42733 # Additional macosx handling
42734 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
42735 # Setting these parameters makes it an error to link to macosx APIs that are
42736 # newer than the given OS version and makes the linked binaries compatible
42737 # even if built on a newer version of the OS.
42738 # The expected format is X.Y.Z
42739 MACOSX_VERSION_MIN=10.7.0
42740
42741
42742 # The macro takes the version with no dots, ex: 1070
42743 # Let the flags variables get resolved in make for easier override on make
42744 # command line.
42745 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
42746 LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
42747 fi
42748
42749 # Setup some hard coded includes
42750 COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
42751 -I${JDK_TOPDIR}/src/java.base/share/native/include \
42752 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS/native/include \
42753 -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/include"
42754
42755 # The shared libraries are compiled using the picflag.
42756 CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
42757 CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
42758
42759 # Executable flags
42760 CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
42761 CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
42762
42763
42764
42765
42766
42767
42768 # Setup LDFLAGS et al.
42769 #
42770
42771 # Now this is odd. The JDK native libraries have to link against libjvm.so
42772 # On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
42773 # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
44669
44670 windows_path="$new_path"
44671 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44672 unix_path=`$CYGPATH -u "$windows_path"`
44673 new_path="$unix_path"
44674 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44675 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44676 new_path="$unix_path"
44677 fi
44678
44679 if test "x$path" != "x$new_path"; then
44680 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
44681 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
44682 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
44683 fi
44684
44685 # Save the first 10 bytes of this path to the storage, so fixpath can work.
44686 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
44687
44688 else
44689 # We're on a unix platform. Hooray! :)
44690 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
44691 has_space=`$ECHO "$path" | $GREP " "`
44692 if test "x$has_space" != x; then
44693 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
44694 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
44695 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
44696 fi
44697
44698 # Use eval to expand a potential ~
44699 eval path="$path"
44700 if test ! -f "$path" && test ! -d "$path"; then
44701 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
44702 fi
44703
44704 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
44705 fi
44706
44707
44708 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44709
44791
44792 windows_path="$new_path"
44793 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
44794 unix_path=`$CYGPATH -u "$windows_path"`
44795 new_path="$unix_path"
44796 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
44797 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
44798 new_path="$unix_path"
44799 fi
44800
44801 if test "x$path" != "x$new_path"; then
44802 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
44803 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
44804 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
44805 fi
44806
44807 # Save the first 10 bytes of this path to the storage, so fixpath can work.
44808 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
44809
44810 else
44811 # We're on a unix platform. Hooray! :)
44812 path="$POTENTIAL_FREETYPE_LIB_PATH"
44813 has_space=`$ECHO "$path" | $GREP " "`
44814 if test "x$has_space" != x; then
44815 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
44816 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
44817 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
44818 fi
44819
44820 # Use eval to expand a potential ~
44821 eval path="$path"
44822 if test ! -f "$path" && test ! -d "$path"; then
44823 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
44824 fi
44825
44826 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
44827 fi
44828
44829
44830 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
44831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
44997
44998 windows_path="$new_path"
44999 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45000 unix_path=`$CYGPATH -u "$windows_path"`
45001 new_path="$unix_path"
45002 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45003 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45004 new_path="$unix_path"
45005 fi
45006
45007 if test "x$path" != "x$new_path"; then
45008 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45009 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45010 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45011 fi
45012
45013 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45014 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45015
45016 else
45017 # We're on a unix platform. Hooray! :)
45018 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45019 has_space=`$ECHO "$path" | $GREP " "`
45020 if test "x$has_space" != x; then
45021 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
45022 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
45023 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45024 fi
45025
45026 # Use eval to expand a potential ~
45027 eval path="$path"
45028 if test ! -f "$path" && test ! -d "$path"; then
45029 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45030 fi
45031
45032 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
45033 fi
45034
45035
45036 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45037
45119
45120 windows_path="$new_path"
45121 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45122 unix_path=`$CYGPATH -u "$windows_path"`
45123 new_path="$unix_path"
45124 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45125 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45126 new_path="$unix_path"
45127 fi
45128
45129 if test "x$path" != "x$new_path"; then
45130 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45131 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45132 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45133 fi
45134
45135 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45136 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45137
45138 else
45139 # We're on a unix platform. Hooray! :)
45140 path="$POTENTIAL_FREETYPE_LIB_PATH"
45141 has_space=`$ECHO "$path" | $GREP " "`
45142 if test "x$has_space" != x; then
45143 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
45144 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
45145 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45146 fi
45147
45148 # Use eval to expand a potential ~
45149 eval path="$path"
45150 if test ! -f "$path" && test ! -d "$path"; then
45151 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45152 fi
45153
45154 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
45155 fi
45156
45157
45158 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45159 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
45586
45587 windows_path="$new_path"
45588 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45589 unix_path=`$CYGPATH -u "$windows_path"`
45590 new_path="$unix_path"
45591 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45592 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45593 new_path="$unix_path"
45594 fi
45595
45596 if test "x$path" != "x$new_path"; then
45597 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45598 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45599 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45600 fi
45601
45602 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45603 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45604
45605 else
45606 # We're on a unix platform. Hooray! :)
45607 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45608 has_space=`$ECHO "$path" | $GREP " "`
45609 if test "x$has_space" != x; then
45610 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
45611 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
45612 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45613 fi
45614
45615 # Use eval to expand a potential ~
45616 eval path="$path"
45617 if test ! -f "$path" && test ! -d "$path"; then
45618 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45619 fi
45620
45621 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
45622 fi
45623
45624
45625 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45626
45708
45709 windows_path="$new_path"
45710 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45711 unix_path=`$CYGPATH -u "$windows_path"`
45712 new_path="$unix_path"
45713 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45714 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45715 new_path="$unix_path"
45716 fi
45717
45718 if test "x$path" != "x$new_path"; then
45719 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
45720 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
45721 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
45722 fi
45723
45724 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45725 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45726
45727 else
45728 # We're on a unix platform. Hooray! :)
45729 path="$POTENTIAL_FREETYPE_LIB_PATH"
45730 has_space=`$ECHO "$path" | $GREP " "`
45731 if test "x$has_space" != x; then
45732 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
45733 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
45734 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45735 fi
45736
45737 # Use eval to expand a potential ~
45738 eval path="$path"
45739 if test ! -f "$path" && test ! -d "$path"; then
45740 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45741 fi
45742
45743 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
45744 fi
45745
45746
45747 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45748 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
45889
45890 windows_path="$new_path"
45891 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45892 unix_path=`$CYGPATH -u "$windows_path"`
45893 new_path="$unix_path"
45894 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
45895 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
45896 new_path="$unix_path"
45897 fi
45898
45899 if test "x$path" != "x$new_path"; then
45900 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
45901 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
45902 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
45903 fi
45904
45905 # Save the first 10 bytes of this path to the storage, so fixpath can work.
45906 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
45907
45908 else
45909 # We're on a unix platform. Hooray! :)
45910 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
45911 has_space=`$ECHO "$path" | $GREP " "`
45912 if test "x$has_space" != x; then
45913 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
45914 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
45915 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
45916 fi
45917
45918 # Use eval to expand a potential ~
45919 eval path="$path"
45920 if test ! -f "$path" && test ! -d "$path"; then
45921 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
45922 fi
45923
45924 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
45925 fi
45926
45927
45928 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
45929
46011
46012 windows_path="$new_path"
46013 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46014 unix_path=`$CYGPATH -u "$windows_path"`
46015 new_path="$unix_path"
46016 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46017 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46018 new_path="$unix_path"
46019 fi
46020
46021 if test "x$path" != "x$new_path"; then
46022 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46023 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46024 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46025 fi
46026
46027 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46028 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46029
46030 else
46031 # We're on a unix platform. Hooray! :)
46032 path="$POTENTIAL_FREETYPE_LIB_PATH"
46033 has_space=`$ECHO "$path" | $GREP " "`
46034 if test "x$has_space" != x; then
46035 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46036 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46037 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46038 fi
46039
46040 # Use eval to expand a potential ~
46041 eval path="$path"
46042 if test ! -f "$path" && test ! -d "$path"; then
46043 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46044 fi
46045
46046 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46047 fi
46048
46049
46050 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
46183
46184 windows_path="$new_path"
46185 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46186 unix_path=`$CYGPATH -u "$windows_path"`
46187 new_path="$unix_path"
46188 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46189 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46190 new_path="$unix_path"
46191 fi
46192
46193 if test "x$path" != "x$new_path"; then
46194 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46195 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46196 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46197 fi
46198
46199 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46200 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46201
46202 else
46203 # We're on a unix platform. Hooray! :)
46204 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46205 has_space=`$ECHO "$path" | $GREP " "`
46206 if test "x$has_space" != x; then
46207 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
46208 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
46209 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46210 fi
46211
46212 # Use eval to expand a potential ~
46213 eval path="$path"
46214 if test ! -f "$path" && test ! -d "$path"; then
46215 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46216 fi
46217
46218 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
46219 fi
46220
46221
46222 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46223
46305
46306 windows_path="$new_path"
46307 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46308 unix_path=`$CYGPATH -u "$windows_path"`
46309 new_path="$unix_path"
46310 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46311 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46312 new_path="$unix_path"
46313 fi
46314
46315 if test "x$path" != "x$new_path"; then
46316 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46317 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46318 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46319 fi
46320
46321 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46322 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46323
46324 else
46325 # We're on a unix platform. Hooray! :)
46326 path="$POTENTIAL_FREETYPE_LIB_PATH"
46327 has_space=`$ECHO "$path" | $GREP " "`
46328 if test "x$has_space" != x; then
46329 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46330 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46331 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46332 fi
46333
46334 # Use eval to expand a potential ~
46335 eval path="$path"
46336 if test ! -f "$path" && test ! -d "$path"; then
46337 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46338 fi
46339
46340 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46341 fi
46342
46343
46344 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
46477
46478 windows_path="$new_path"
46479 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46480 unix_path=`$CYGPATH -u "$windows_path"`
46481 new_path="$unix_path"
46482 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46483 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46484 new_path="$unix_path"
46485 fi
46486
46487 if test "x$path" != "x$new_path"; then
46488 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46489 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46490 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46491 fi
46492
46493 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46494 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46495
46496 else
46497 # We're on a unix platform. Hooray! :)
46498 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46499 has_space=`$ECHO "$path" | $GREP " "`
46500 if test "x$has_space" != x; then
46501 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
46502 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
46503 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46504 fi
46505
46506 # Use eval to expand a potential ~
46507 eval path="$path"
46508 if test ! -f "$path" && test ! -d "$path"; then
46509 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46510 fi
46511
46512 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
46513 fi
46514
46515
46516 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46517
46599
46600 windows_path="$new_path"
46601 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46602 unix_path=`$CYGPATH -u "$windows_path"`
46603 new_path="$unix_path"
46604 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46605 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46606 new_path="$unix_path"
46607 fi
46608
46609 if test "x$path" != "x$new_path"; then
46610 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46611 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46612 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46613 fi
46614
46615 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46616 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46617
46618 else
46619 # We're on a unix platform. Hooray! :)
46620 path="$POTENTIAL_FREETYPE_LIB_PATH"
46621 has_space=`$ECHO "$path" | $GREP " "`
46622 if test "x$has_space" != x; then
46623 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46624 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46625 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46626 fi
46627
46628 # Use eval to expand a potential ~
46629 eval path="$path"
46630 if test ! -f "$path" && test ! -d "$path"; then
46631 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46632 fi
46633
46634 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46635 fi
46636
46637
46638 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46639 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
46772
46773 windows_path="$new_path"
46774 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46775 unix_path=`$CYGPATH -u "$windows_path"`
46776 new_path="$unix_path"
46777 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46778 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46779 new_path="$unix_path"
46780 fi
46781
46782 if test "x$path" != "x$new_path"; then
46783 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
46784 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
46785 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
46786 fi
46787
46788 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46789 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46790
46791 else
46792 # We're on a unix platform. Hooray! :)
46793 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46794 has_space=`$ECHO "$path" | $GREP " "`
46795 if test "x$has_space" != x; then
46796 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
46797 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
46798 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46799 fi
46800
46801 # Use eval to expand a potential ~
46802 eval path="$path"
46803 if test ! -f "$path" && test ! -d "$path"; then
46804 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46805 fi
46806
46807 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
46808 fi
46809
46810
46811 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46812
46894
46895 windows_path="$new_path"
46896 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
46897 unix_path=`$CYGPATH -u "$windows_path"`
46898 new_path="$unix_path"
46899 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
46900 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
46901 new_path="$unix_path"
46902 fi
46903
46904 if test "x$path" != "x$new_path"; then
46905 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
46906 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
46907 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
46908 fi
46909
46910 # Save the first 10 bytes of this path to the storage, so fixpath can work.
46911 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
46912
46913 else
46914 # We're on a unix platform. Hooray! :)
46915 path="$POTENTIAL_FREETYPE_LIB_PATH"
46916 has_space=`$ECHO "$path" | $GREP " "`
46917 if test "x$has_space" != x; then
46918 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
46919 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
46920 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
46921 fi
46922
46923 # Use eval to expand a potential ~
46924 eval path="$path"
46925 if test ! -f "$path" && test ! -d "$path"; then
46926 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
46927 fi
46928
46929 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
46930 fi
46931
46932
46933 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
46934 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47068
47069 windows_path="$new_path"
47070 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47071 unix_path=`$CYGPATH -u "$windows_path"`
47072 new_path="$unix_path"
47073 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47074 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47075 new_path="$unix_path"
47076 fi
47077
47078 if test "x$path" != "x$new_path"; then
47079 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
47080 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47081 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47082 fi
47083
47084 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47085 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47086
47087 else
47088 # We're on a unix platform. Hooray! :)
47089 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47090 has_space=`$ECHO "$path" | $GREP " "`
47091 if test "x$has_space" != x; then
47092 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47093 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47094 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47095 fi
47096
47097 # Use eval to expand a potential ~
47098 eval path="$path"
47099 if test ! -f "$path" && test ! -d "$path"; then
47100 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47101 fi
47102
47103 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47104 fi
47105
47106
47107 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47108
47190
47191 windows_path="$new_path"
47192 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47193 unix_path=`$CYGPATH -u "$windows_path"`
47194 new_path="$unix_path"
47195 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47196 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47197 new_path="$unix_path"
47198 fi
47199
47200 if test "x$path" != "x$new_path"; then
47201 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
47202 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
47203 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47204 fi
47205
47206 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47207 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47208
47209 else
47210 # We're on a unix platform. Hooray! :)
47211 path="$POTENTIAL_FREETYPE_LIB_PATH"
47212 has_space=`$ECHO "$path" | $GREP " "`
47213 if test "x$has_space" != x; then
47214 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
47215 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
47216 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47217 fi
47218
47219 # Use eval to expand a potential ~
47220 eval path="$path"
47221 if test ! -f "$path" && test ! -d "$path"; then
47222 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47223 fi
47224
47225 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
47226 fi
47227
47228
47229 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47230 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47360
47361 windows_path="$new_path"
47362 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47363 unix_path=`$CYGPATH -u "$windows_path"`
47364 new_path="$unix_path"
47365 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47366 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47367 new_path="$unix_path"
47368 fi
47369
47370 if test "x$path" != "x$new_path"; then
47371 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
47372 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47373 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47374 fi
47375
47376 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47377 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47378
47379 else
47380 # We're on a unix platform. Hooray! :)
47381 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47382 has_space=`$ECHO "$path" | $GREP " "`
47383 if test "x$has_space" != x; then
47384 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47385 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47386 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47387 fi
47388
47389 # Use eval to expand a potential ~
47390 eval path="$path"
47391 if test ! -f "$path" && test ! -d "$path"; then
47392 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47393 fi
47394
47395 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47396 fi
47397
47398
47399 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47400
47482
47483 windows_path="$new_path"
47484 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47485 unix_path=`$CYGPATH -u "$windows_path"`
47486 new_path="$unix_path"
47487 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47488 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47489 new_path="$unix_path"
47490 fi
47491
47492 if test "x$path" != "x$new_path"; then
47493 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
47494 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
47495 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47496 fi
47497
47498 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47499 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47500
47501 else
47502 # We're on a unix platform. Hooray! :)
47503 path="$POTENTIAL_FREETYPE_LIB_PATH"
47504 has_space=`$ECHO "$path" | $GREP " "`
47505 if test "x$has_space" != x; then
47506 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
47507 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
47508 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47509 fi
47510
47511 # Use eval to expand a potential ~
47512 eval path="$path"
47513 if test ! -f "$path" && test ! -d "$path"; then
47514 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47515 fi
47516
47517 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
47518 fi
47519
47520
47521 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47652
47653 windows_path="$new_path"
47654 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47655 unix_path=`$CYGPATH -u "$windows_path"`
47656 new_path="$unix_path"
47657 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47658 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47659 new_path="$unix_path"
47660 fi
47661
47662 if test "x$path" != "x$new_path"; then
47663 POTENTIAL_FREETYPE_INCLUDE_PATH="$new_path"
47664 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47665 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47666 fi
47667
47668 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47669 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47670
47671 else
47672 # We're on a unix platform. Hooray! :)
47673 path="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47674 has_space=`$ECHO "$path" | $GREP " "`
47675 if test "x$has_space" != x; then
47676 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47677 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47678 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47679 fi
47680
47681 # Use eval to expand a potential ~
47682 eval path="$path"
47683 if test ! -f "$path" && test ! -d "$path"; then
47684 as_fn_error $? "The path of POTENTIAL_FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47685 fi
47686
47687 POTENTIAL_FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47688 fi
47689
47690
47691 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47692
47774
47775 windows_path="$new_path"
47776 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47777 unix_path=`$CYGPATH -u "$windows_path"`
47778 new_path="$unix_path"
47779 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47780 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47781 new_path="$unix_path"
47782 fi
47783
47784 if test "x$path" != "x$new_path"; then
47785 POTENTIAL_FREETYPE_LIB_PATH="$new_path"
47786 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&5
47787 $as_echo "$as_me: Rewriting POTENTIAL_FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
47788 fi
47789
47790 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47791 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47792
47793 else
47794 # We're on a unix platform. Hooray! :)
47795 path="$POTENTIAL_FREETYPE_LIB_PATH"
47796 has_space=`$ECHO "$path" | $GREP " "`
47797 if test "x$has_space" != x; then
47798 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
47799 $as_echo "$as_me: The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
47800 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47801 fi
47802
47803 # Use eval to expand a potential ~
47804 eval path="$path"
47805 if test ! -f "$path" && test ! -d "$path"; then
47806 as_fn_error $? "The path of POTENTIAL_FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47807 fi
47808
47809 POTENTIAL_FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
47810 fi
47811
47812
47813 FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
47814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
47952
47953 windows_path="$new_path"
47954 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
47955 unix_path=`$CYGPATH -u "$windows_path"`
47956 new_path="$unix_path"
47957 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
47958 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
47959 new_path="$unix_path"
47960 fi
47961
47962 if test "x$path" != "x$new_path"; then
47963 FREETYPE_INCLUDE_PATH="$new_path"
47964 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&5
47965 $as_echo "$as_me: Rewriting FREETYPE_INCLUDE_PATH to \"$new_path\"" >&6;}
47966 fi
47967
47968 # Save the first 10 bytes of this path to the storage, so fixpath can work.
47969 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
47970
47971 else
47972 # We're on a unix platform. Hooray! :)
47973 path="$FREETYPE_INCLUDE_PATH"
47974 has_space=`$ECHO "$path" | $GREP " "`
47975 if test "x$has_space" != x; then
47976 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
47977 $as_echo "$as_me: The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
47978 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
47979 fi
47980
47981 # Use eval to expand a potential ~
47982 eval path="$path"
47983 if test ! -f "$path" && test ! -d "$path"; then
47984 as_fn_error $? "The path of FREETYPE_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
47985 fi
47986
47987 FREETYPE_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
47988 fi
47989
47990 if test -d $FREETYPE_INCLUDE_PATH/freetype2/freetype; then
47991 FREETYPE_CFLAGS="-I$FREETYPE_INCLUDE_PATH/freetype2 -I$FREETYPE_INCLUDE_PATH"
47992 else
48082
48083 windows_path="$new_path"
48084 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
48085 unix_path=`$CYGPATH -u "$windows_path"`
48086 new_path="$unix_path"
48087 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
48088 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
48089 new_path="$unix_path"
48090 fi
48091
48092 if test "x$path" != "x$new_path"; then
48093 FREETYPE_LIB_PATH="$new_path"
48094 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&5
48095 $as_echo "$as_me: Rewriting FREETYPE_LIB_PATH to \"$new_path\"" >&6;}
48096 fi
48097
48098 # Save the first 10 bytes of this path to the storage, so fixpath can work.
48099 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
48100
48101 else
48102 # We're on a unix platform. Hooray! :)
48103 path="$FREETYPE_LIB_PATH"
48104 has_space=`$ECHO "$path" | $GREP " "`
48105 if test "x$has_space" != x; then
48106 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&5
48107 $as_echo "$as_me: The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
48108 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
48109 fi
48110
48111 # Use eval to expand a potential ~
48112 eval path="$path"
48113 if test ! -f "$path" && test ! -d "$path"; then
48114 as_fn_error $? "The path of FREETYPE_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
48115 fi
48116
48117 FREETYPE_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
48118 fi
48119
48120 if test "x$OPENJDK_TARGET_OS" = xwindows; then
48121 FREETYPE_LIBS="$FREETYPE_LIB_PATH/freetype.lib"
48122 else
49981
49982 windows_path="$new_path"
49983 if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
49984 unix_path=`$CYGPATH -u "$windows_path"`
49985 new_path="$unix_path"
49986 elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
49987 unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
49988 new_path="$unix_path"
49989 fi
49990
49991 if test "x$path" != "x$new_path"; then
49992 MSVCR_DLL="$new_path"
49993 { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVCR_DLL to \"$new_path\"" >&5
49994 $as_echo "$as_me: Rewriting MSVCR_DLL to \"$new_path\"" >&6;}
49995 fi
49996
49997 # Save the first 10 bytes of this path to the storage, so fixpath can work.
49998 all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
49999
50000 else
50001 # We're on a unix platform. Hooray! :)
50002 path="$MSVCR_DLL"
50003 has_space=`$ECHO "$path" | $GREP " "`
50004 if test "x$has_space" != x; then
50005 { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&5
50006 $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid." >&6;}
50007 as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
50008 fi
50009
50010 # Use eval to expand a potential ~
50011 eval path="$path"
50012 if test ! -f "$path" && test ! -d "$path"; then
50013 as_fn_error $? "The path of MSVCR_DLL, which resolves as \"$path\", is not found." "$LINENO" 5
50014 fi
50015
50016 MSVCR_DLL="`cd "$path"; $THEPWDCMD -L`"
50017 fi
50018
50019
50020
50021
|