3848 
3849 # Check if the VS env variables were setup prior to running configure.
3850 # If not, then find vcvarsall.bat and run it automatically, and integrate
3851 # the set env variables into the spec file.
3852 
3853 
3854 
3855 
3856 
3857 
3858 
3859 
3860 
3861 
3862 # This line needs to be here, verbatim, after all includes and the dummy hook
3863 # definitions. It is replaced with custom functionality when building
3864 # custom sources.
3865 #CUSTOM_AUTOCONF_INCLUDE
3866 
3867 # Do not change or remove the following line, it is needed for consistency checks:
3868 DATE_WHEN_GENERATED=1384422786
3869 
3870 ###############################################################################
3871 #
3872 # Initialization / Boot-strapping
3873 #
3874 # The bootstrapping process needs to solve the "chicken or the egg" problem,
3875 # thus it jumps back and forth, each time gaining something needed later on.
3876 #
3877 ###############################################################################
3878 
3879 # Basic initialization that must happen first of all
3880 
3881   # Save the original command line. This is passed to us by the wrapper configure script.
3882 
3883   DATE_WHEN_CONFIGURED=`LANG=C date`
3884 
3885   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
3886 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
3887   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
3888 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}

11264         BOOT_JDK_FOUND=no
11265       else
11266         # Do we have a bin/javac?
11267         if test ! -x "$BOOT_JDK/bin/javac"; then
11268           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
11269 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
11270           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
11271 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
11272           BOOT_JDK_FOUND=no
11273         else
11274           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
11275           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
11276             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
11277 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
11278             BOOT_JDK_FOUND=no
11279           else
11280             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
11281             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
11282 
11283             # Extra M4 quote needed to protect [] in grep expression.
11284             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
11285             if test "x$FOUND_VERSION_78" = x; then
11286               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
11287 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
11288               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
11289 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
11290               BOOT_JDK_FOUND=no
11291             else
11292               # We're done! :-)
11293               BOOT_JDK_FOUND=yes
11294 
11295   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
11296 
11297   # Input might be given as Windows format, start by converting to
11298   # unix format.
11299   path="$BOOT_JDK"
11300   new_path=`$CYGPATH -u "$path"`
11301 
11302   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
11303   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
11304   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
11305   # "foo.exe" is OK but "foo" is an error.
11306   #
11307   # This test is therefore slightly more accurate than "test -f" to check for file precense.
11308   # It is also a way to make sure we got the proper file name for the real test later on.
11309   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

11596         BOOT_JDK_FOUND=no
11597       else
11598         # Do we have a bin/javac?
11599         if test ! -x "$BOOT_JDK/bin/javac"; then
11600           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
11601 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
11602           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
11603 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
11604           BOOT_JDK_FOUND=no
11605         else
11606           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
11607           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
11608             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
11609 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
11610             BOOT_JDK_FOUND=no
11611           else
11612             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
11613             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
11614 
11615             # Extra M4 quote needed to protect [] in grep expression.
11616             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
11617             if test "x$FOUND_VERSION_78" = x; then
11618               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
11619 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
11620               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
11621 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
11622               BOOT_JDK_FOUND=no
11623             else
11624               # We're done! :-)
11625               BOOT_JDK_FOUND=yes
11626 
11627   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
11628 
11629   # Input might be given as Windows format, start by converting to
11630   # unix format.
11631   path="$BOOT_JDK"
11632   new_path=`$CYGPATH -u "$path"`
11633 
11634   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
11635   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
11636   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
11637   # "foo.exe" is OK but "foo" is an error.
11638   #
11639   # This test is therefore slightly more accurate than "test -f" to check for file precense.
11640   # It is also a way to make sure we got the proper file name for the real test later on.
11641   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

11914         BOOT_JDK_FOUND=no
11915       else
11916         # Do we have a bin/javac?
11917         if test ! -x "$BOOT_JDK/bin/javac"; then
11918           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
11919 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
11920           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
11921 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
11922           BOOT_JDK_FOUND=no
11923         else
11924           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
11925           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
11926             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
11927 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
11928             BOOT_JDK_FOUND=no
11929           else
11930             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
11931             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
11932 
11933             # Extra M4 quote needed to protect [] in grep expression.
11934             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
11935             if test "x$FOUND_VERSION_78" = x; then
11936               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
11937 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
11938               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
11939 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
11940               BOOT_JDK_FOUND=no
11941             else
11942               # We're done! :-)
11943               BOOT_JDK_FOUND=yes
11944 
11945   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
11946 
11947   # Input might be given as Windows format, start by converting to
11948   # unix format.
11949   path="$BOOT_JDK"
11950   new_path=`$CYGPATH -u "$path"`
11951 
11952   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
11953   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
11954   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
11955   # "foo.exe" is OK but "foo" is an error.
11956   #
11957   # This test is therefore slightly more accurate than "test -f" to check for file precense.
11958   # It is also a way to make sure we got the proper file name for the real test later on.
11959   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12102         BOOT_JDK_FOUND=no
12103       else
12104         # Do we have a bin/javac?
12105         if test ! -x "$BOOT_JDK/bin/javac"; then
12106           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12107 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12108           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12109 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12110           BOOT_JDK_FOUND=no
12111         else
12112           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12113           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12114             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12115 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12116             BOOT_JDK_FOUND=no
12117           else
12118             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12119             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12120 
12121             # Extra M4 quote needed to protect [] in grep expression.
12122             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
12123             if test "x$FOUND_VERSION_78" = x; then
12124               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12125 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12126               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
12127 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
12128               BOOT_JDK_FOUND=no
12129             else
12130               # We're done! :-)
12131               BOOT_JDK_FOUND=yes
12132 
12133   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12134 
12135   # Input might be given as Windows format, start by converting to
12136   # unix format.
12137   path="$BOOT_JDK"
12138   new_path=`$CYGPATH -u "$path"`
12139 
12140   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12141   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12142   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12143   # "foo.exe" is OK but "foo" is an error.
12144   #
12145   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12146   # It is also a way to make sure we got the proper file name for the real test later on.
12147   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12430         BOOT_JDK_FOUND=no
12431       else
12432         # Do we have a bin/javac?
12433         if test ! -x "$BOOT_JDK/bin/javac"; then
12434           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12435 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12436           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12437 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12438           BOOT_JDK_FOUND=no
12439         else
12440           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12441           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12442             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12443 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12444             BOOT_JDK_FOUND=no
12445           else
12446             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12447             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12448 
12449             # Extra M4 quote needed to protect [] in grep expression.
12450             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
12451             if test "x$FOUND_VERSION_78" = x; then
12452               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12453 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12454               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
12455 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
12456               BOOT_JDK_FOUND=no
12457             else
12458               # We're done! :-)
12459               BOOT_JDK_FOUND=yes
12460 
12461   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12462 
12463   # Input might be given as Windows format, start by converting to
12464   # unix format.
12465   path="$BOOT_JDK"
12466   new_path=`$CYGPATH -u "$path"`
12467 
12468   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12469   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12470   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12471   # "foo.exe" is OK but "foo" is an error.
12472   #
12473   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12474   # It is also a way to make sure we got the proper file name for the real test later on.
12475   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12645         BOOT_JDK_FOUND=no
12646       else
12647         # Do we have a bin/javac?
12648         if test ! -x "$BOOT_JDK/bin/javac"; then
12649           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12650 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12651           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12652 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12653           BOOT_JDK_FOUND=no
12654         else
12655           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12656           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12657             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12658 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12659             BOOT_JDK_FOUND=no
12660           else
12661             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12662             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12663 
12664             # Extra M4 quote needed to protect [] in grep expression.
12665             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
12666             if test "x$FOUND_VERSION_78" = x; then
12667               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12668 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12669               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
12670 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
12671               BOOT_JDK_FOUND=no
12672             else
12673               # We're done! :-)
12674               BOOT_JDK_FOUND=yes
12675 
12676   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12677 
12678   # Input might be given as Windows format, start by converting to
12679   # unix format.
12680   path="$BOOT_JDK"
12681   new_path=`$CYGPATH -u "$path"`
12682 
12683   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12684   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12685   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12686   # "foo.exe" is OK but "foo" is an error.
12687   #
12688   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12689   # It is also a way to make sure we got the proper file name for the real test later on.
12690   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12825         BOOT_JDK_FOUND=no
12826       else
12827         # Do we have a bin/javac?
12828         if test ! -x "$BOOT_JDK/bin/javac"; then
12829           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12830 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12831           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12832 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12833           BOOT_JDK_FOUND=no
12834         else
12835           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12836           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12837             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12838 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12839             BOOT_JDK_FOUND=no
12840           else
12841             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12842             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12843 
12844             # Extra M4 quote needed to protect [] in grep expression.
12845             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
12846             if test "x$FOUND_VERSION_78" = x; then
12847               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12848 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12849               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
12850 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
12851               BOOT_JDK_FOUND=no
12852             else
12853               # We're done! :-)
12854               BOOT_JDK_FOUND=yes
12855 
12856   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12857 
12858   # Input might be given as Windows format, start by converting to
12859   # unix format.
12860   path="$BOOT_JDK"
12861   new_path=`$CYGPATH -u "$path"`
12862 
12863   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12864   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12865   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12866   # "foo.exe" is OK but "foo" is an error.
12867   #
12868   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12869   # It is also a way to make sure we got the proper file name for the real test later on.
12870   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13033         BOOT_JDK_FOUND=no
13034       else
13035         # Do we have a bin/javac?
13036         if test ! -x "$BOOT_JDK/bin/javac"; then
13037           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13038 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13039           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13040 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13041           BOOT_JDK_FOUND=no
13042         else
13043           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13044           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13045             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13046 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13047             BOOT_JDK_FOUND=no
13048           else
13049             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13050             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13051 
13052             # Extra M4 quote needed to protect [] in grep expression.
13053             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
13054             if test "x$FOUND_VERSION_78" = x; then
13055               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13056 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13057               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
13058 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
13059               BOOT_JDK_FOUND=no
13060             else
13061               # We're done! :-)
13062               BOOT_JDK_FOUND=yes
13063 
13064   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13065 
13066   # Input might be given as Windows format, start by converting to
13067   # unix format.
13068   path="$BOOT_JDK"
13069   new_path=`$CYGPATH -u "$path"`
13070 
13071   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13072   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13073   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13074   # "foo.exe" is OK but "foo" is an error.
13075   #
13076   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13077   # It is also a way to make sure we got the proper file name for the real test later on.
13078   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13213         BOOT_JDK_FOUND=no
13214       else
13215         # Do we have a bin/javac?
13216         if test ! -x "$BOOT_JDK/bin/javac"; then
13217           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13219           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13220 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13221           BOOT_JDK_FOUND=no
13222         else
13223           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13224           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13225             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13226 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13227             BOOT_JDK_FOUND=no
13228           else
13229             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13230             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13231 
13232             # Extra M4 quote needed to protect [] in grep expression.
13233             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
13234             if test "x$FOUND_VERSION_78" = x; then
13235               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13236 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13237               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
13238 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
13239               BOOT_JDK_FOUND=no
13240             else
13241               # We're done! :-)
13242               BOOT_JDK_FOUND=yes
13243 
13244   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13245 
13246   # Input might be given as Windows format, start by converting to
13247   # unix format.
13248   path="$BOOT_JDK"
13249   new_path=`$CYGPATH -u "$path"`
13250 
13251   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13252   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13253   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13254   # "foo.exe" is OK but "foo" is an error.
13255   #
13256   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13257   # It is also a way to make sure we got the proper file name for the real test later on.
13258   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13421         BOOT_JDK_FOUND=no
13422       else
13423         # Do we have a bin/javac?
13424         if test ! -x "$BOOT_JDK/bin/javac"; then
13425           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13426 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13427           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13428 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13429           BOOT_JDK_FOUND=no
13430         else
13431           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13432           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13433             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13434 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13435             BOOT_JDK_FOUND=no
13436           else
13437             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13438             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13439 
13440             # Extra M4 quote needed to protect [] in grep expression.
13441             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
13442             if test "x$FOUND_VERSION_78" = x; then
13443               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13444 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13445               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
13446 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
13447               BOOT_JDK_FOUND=no
13448             else
13449               # We're done! :-)
13450               BOOT_JDK_FOUND=yes
13451 
13452   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13453 
13454   # Input might be given as Windows format, start by converting to
13455   # unix format.
13456   path="$BOOT_JDK"
13457   new_path=`$CYGPATH -u "$path"`
13458 
13459   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13460   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13461   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13462   # "foo.exe" is OK but "foo" is an error.
13463   #
13464   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13465   # It is also a way to make sure we got the proper file name for the real test later on.
13466   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13601         BOOT_JDK_FOUND=no
13602       else
13603         # Do we have a bin/javac?
13604         if test ! -x "$BOOT_JDK/bin/javac"; then
13605           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13606 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13607           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13608 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13609           BOOT_JDK_FOUND=no
13610         else
13611           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13612           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13613             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13614 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13615             BOOT_JDK_FOUND=no
13616           else
13617             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13618             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13619 
13620             # Extra M4 quote needed to protect [] in grep expression.
13621             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
13622             if test "x$FOUND_VERSION_78" = x; then
13623               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13624 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13625               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
13626 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
13627               BOOT_JDK_FOUND=no
13628             else
13629               # We're done! :-)
13630               BOOT_JDK_FOUND=yes
13631 
13632   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13633 
13634   # Input might be given as Windows format, start by converting to
13635   # unix format.
13636   path="$BOOT_JDK"
13637   new_path=`$CYGPATH -u "$path"`
13638 
13639   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13640   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13641   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13642   # "foo.exe" is OK but "foo" is an error.
13643   #
13644   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13645   # It is also a way to make sure we got the proper file name for the real test later on.
13646   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13809         BOOT_JDK_FOUND=no
13810       else
13811         # Do we have a bin/javac?
13812         if test ! -x "$BOOT_JDK/bin/javac"; then
13813           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13814 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13815           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13816 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13817           BOOT_JDK_FOUND=no
13818         else
13819           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13820           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13821             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13822 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13823             BOOT_JDK_FOUND=no
13824           else
13825             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13826             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13827 
13828             # Extra M4 quote needed to protect [] in grep expression.
13829             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
13830             if test "x$FOUND_VERSION_78" = x; then
13831               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13832 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13833               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
13834 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
13835               BOOT_JDK_FOUND=no
13836             else
13837               # We're done! :-)
13838               BOOT_JDK_FOUND=yes
13839 
13840   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13841 
13842   # Input might be given as Windows format, start by converting to
13843   # unix format.
13844   path="$BOOT_JDK"
13845   new_path=`$CYGPATH -u "$path"`
13846 
13847   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13848   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13849   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13850   # "foo.exe" is OK but "foo" is an error.
13851   #
13852   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13853   # It is also a way to make sure we got the proper file name for the real test later on.
13854   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13989         BOOT_JDK_FOUND=no
13990       else
13991         # Do we have a bin/javac?
13992         if test ! -x "$BOOT_JDK/bin/javac"; then
13993           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13995           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13996 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13997           BOOT_JDK_FOUND=no
13998         else
13999           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14000           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14001             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14002 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14003             BOOT_JDK_FOUND=no
14004           else
14005             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14006             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14007 
14008             # Extra M4 quote needed to protect [] in grep expression.
14009             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
14010             if test "x$FOUND_VERSION_78" = x; then
14011               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14012 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14013               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
14014 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
14015               BOOT_JDK_FOUND=no
14016             else
14017               # We're done! :-)
14018               BOOT_JDK_FOUND=yes
14019 
14020   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14021 
14022   # Input might be given as Windows format, start by converting to
14023   # unix format.
14024   path="$BOOT_JDK"
14025   new_path=`$CYGPATH -u "$path"`
14026 
14027   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14028   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14029   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14030   # "foo.exe" is OK but "foo" is an error.
14031   #
14032   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14033   # It is also a way to make sure we got the proper file name for the real test later on.
14034   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14184         BOOT_JDK_FOUND=no
14185       else
14186         # Do we have a bin/javac?
14187         if test ! -x "$BOOT_JDK/bin/javac"; then
14188           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14189 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14190           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14191 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14192           BOOT_JDK_FOUND=no
14193         else
14194           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14195           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14196             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14197 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14198             BOOT_JDK_FOUND=no
14199           else
14200             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14201             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14202 
14203             # Extra M4 quote needed to protect [] in grep expression.
14204             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
14205             if test "x$FOUND_VERSION_78" = x; then
14206               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14207 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14208               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
14209 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
14210               BOOT_JDK_FOUND=no
14211             else
14212               # We're done! :-)
14213               BOOT_JDK_FOUND=yes
14214 
14215   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14216 
14217   # Input might be given as Windows format, start by converting to
14218   # unix format.
14219   path="$BOOT_JDK"
14220   new_path=`$CYGPATH -u "$path"`
14221 
14222   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14223   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14224   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14225   # "foo.exe" is OK but "foo" is an error.
14226   #
14227   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14228   # It is also a way to make sure we got the proper file name for the real test later on.
14229   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14362         BOOT_JDK_FOUND=no
14363       else
14364         # Do we have a bin/javac?
14365         if test ! -x "$BOOT_JDK/bin/javac"; then
14366           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14367 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14368           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14369 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14370           BOOT_JDK_FOUND=no
14371         else
14372           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14373           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14374             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14375 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14376             BOOT_JDK_FOUND=no
14377           else
14378             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14379             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14380 
14381             # Extra M4 quote needed to protect [] in grep expression.
14382             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
14383             if test "x$FOUND_VERSION_78" = x; then
14384               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14385 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14386               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
14387 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
14388               BOOT_JDK_FOUND=no
14389             else
14390               # We're done! :-)
14391               BOOT_JDK_FOUND=yes
14392 
14393   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14394 
14395   # Input might be given as Windows format, start by converting to
14396   # unix format.
14397   path="$BOOT_JDK"
14398   new_path=`$CYGPATH -u "$path"`
14399 
14400   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14401   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14402   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14403   # "foo.exe" is OK but "foo" is an error.
14404   #
14405   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14406   # It is also a way to make sure we got the proper file name for the real test later on.
14407   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14558         BOOT_JDK_FOUND=no
14559       else
14560         # Do we have a bin/javac?
14561         if test ! -x "$BOOT_JDK/bin/javac"; then
14562           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14563 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14564           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14565 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14566           BOOT_JDK_FOUND=no
14567         else
14568           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14569           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14570             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14571 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14572             BOOT_JDK_FOUND=no
14573           else
14574             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14575             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14576 
14577             # Extra M4 quote needed to protect [] in grep expression.
14578             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
14579             if test "x$FOUND_VERSION_78" = x; then
14580               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14581 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14582               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
14583 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
14584               BOOT_JDK_FOUND=no
14585             else
14586               # We're done! :-)
14587               BOOT_JDK_FOUND=yes
14588 
14589   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14590 
14591   # Input might be given as Windows format, start by converting to
14592   # unix format.
14593   path="$BOOT_JDK"
14594   new_path=`$CYGPATH -u "$path"`
14595 
14596   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14597   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14598   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14599   # "foo.exe" is OK but "foo" is an error.
14600   #
14601   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14602   # It is also a way to make sure we got the proper file name for the real test later on.
14603   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14736         BOOT_JDK_FOUND=no
14737       else
14738         # Do we have a bin/javac?
14739         if test ! -x "$BOOT_JDK/bin/javac"; then
14740           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14741 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14742           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14743 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14744           BOOT_JDK_FOUND=no
14745         else
14746           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14747           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14748             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14749 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14750             BOOT_JDK_FOUND=no
14751           else
14752             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14753             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14754 
14755             # Extra M4 quote needed to protect [] in grep expression.
14756             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
14757             if test "x$FOUND_VERSION_78" = x; then
14758               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14759 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14760               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
14761 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
14762               BOOT_JDK_FOUND=no
14763             else
14764               # We're done! :-)
14765               BOOT_JDK_FOUND=yes
14766 
14767   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14768 
14769   # Input might be given as Windows format, start by converting to
14770   # unix format.
14771   path="$BOOT_JDK"
14772   new_path=`$CYGPATH -u "$path"`
14773 
14774   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14775   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14776   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14777   # "foo.exe" is OK but "foo" is an error.
14778   #
14779   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14780   # It is also a way to make sure we got the proper file name for the real test later on.
14781   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14931         BOOT_JDK_FOUND=no
14932       else
14933         # Do we have a bin/javac?
14934         if test ! -x "$BOOT_JDK/bin/javac"; then
14935           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14936 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14937           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14938 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14939           BOOT_JDK_FOUND=no
14940         else
14941           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14942           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14943             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14944 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14945             BOOT_JDK_FOUND=no
14946           else
14947             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14948             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14949 
14950             # Extra M4 quote needed to protect [] in grep expression.
14951             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
14952             if test "x$FOUND_VERSION_78" = x; then
14953               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14954 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14955               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
14956 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
14957               BOOT_JDK_FOUND=no
14958             else
14959               # We're done! :-)
14960               BOOT_JDK_FOUND=yes
14961 
14962   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14963 
14964   # Input might be given as Windows format, start by converting to
14965   # unix format.
14966   path="$BOOT_JDK"
14967   new_path=`$CYGPATH -u "$path"`
14968 
14969   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14970   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14971   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14972   # "foo.exe" is OK but "foo" is an error.
14973   #
14974   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14975   # It is also a way to make sure we got the proper file name for the real test later on.
14976   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15109         BOOT_JDK_FOUND=no
15110       else
15111         # Do we have a bin/javac?
15112         if test ! -x "$BOOT_JDK/bin/javac"; then
15113           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15114 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15115           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15116 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15117           BOOT_JDK_FOUND=no
15118         else
15119           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15120           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15121             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15122 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15123             BOOT_JDK_FOUND=no
15124           else
15125             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15126             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15127 
15128             # Extra M4 quote needed to protect [] in grep expression.
15129             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
15130             if test "x$FOUND_VERSION_78" = x; then
15131               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15132 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15133               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
15134 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
15135               BOOT_JDK_FOUND=no
15136             else
15137               # We're done! :-)
15138               BOOT_JDK_FOUND=yes
15139 
15140   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15141 
15142   # Input might be given as Windows format, start by converting to
15143   # unix format.
15144   path="$BOOT_JDK"
15145   new_path=`$CYGPATH -u "$path"`
15146 
15147   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15148   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15149   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15150   # "foo.exe" is OK but "foo" is an error.
15151   #
15152   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15153   # It is also a way to make sure we got the proper file name for the real test later on.
15154   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15305         BOOT_JDK_FOUND=no
15306       else
15307         # Do we have a bin/javac?
15308         if test ! -x "$BOOT_JDK/bin/javac"; then
15309           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15310 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15311           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15312 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15313           BOOT_JDK_FOUND=no
15314         else
15315           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15316           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15317             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15318 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15319             BOOT_JDK_FOUND=no
15320           else
15321             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15322             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15323 
15324             # Extra M4 quote needed to protect [] in grep expression.
15325             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
15326             if test "x$FOUND_VERSION_78" = x; then
15327               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15328 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15329               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
15330 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
15331               BOOT_JDK_FOUND=no
15332             else
15333               # We're done! :-)
15334               BOOT_JDK_FOUND=yes
15335 
15336   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15337 
15338   # Input might be given as Windows format, start by converting to
15339   # unix format.
15340   path="$BOOT_JDK"
15341   new_path=`$CYGPATH -u "$path"`
15342 
15343   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15344   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15345   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15346   # "foo.exe" is OK but "foo" is an error.
15347   #
15348   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15349   # It is also a way to make sure we got the proper file name for the real test later on.
15350   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15483         BOOT_JDK_FOUND=no
15484       else
15485         # Do we have a bin/javac?
15486         if test ! -x "$BOOT_JDK/bin/javac"; then
15487           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15488 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15489           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15490 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15491           BOOT_JDK_FOUND=no
15492         else
15493           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15494           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15495             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15496 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15497             BOOT_JDK_FOUND=no
15498           else
15499             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15500             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15501 
15502             # Extra M4 quote needed to protect [] in grep expression.
15503             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
15504             if test "x$FOUND_VERSION_78" = x; then
15505               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15506 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15507               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
15508 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
15509               BOOT_JDK_FOUND=no
15510             else
15511               # We're done! :-)
15512               BOOT_JDK_FOUND=yes
15513 
15514   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15515 
15516   # Input might be given as Windows format, start by converting to
15517   # unix format.
15518   path="$BOOT_JDK"
15519   new_path=`$CYGPATH -u "$path"`
15520 
15521   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15522   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15523   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15524   # "foo.exe" is OK but "foo" is an error.
15525   #
15526   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15527   # It is also a way to make sure we got the proper file name for the real test later on.
15528   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15660         BOOT_JDK_FOUND=no
15661       else
15662         # Do we have a bin/javac?
15663         if test ! -x "$BOOT_JDK/bin/javac"; then
15664           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15665 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15666           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15667 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15668           BOOT_JDK_FOUND=no
15669         else
15670           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15671           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15672             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15673 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15674             BOOT_JDK_FOUND=no
15675           else
15676             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15677             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15678 
15679             # Extra M4 quote needed to protect [] in grep expression.
15680             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
15681             if test "x$FOUND_VERSION_78" = x; then
15682               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15683 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15684               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
15685 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
15686               BOOT_JDK_FOUND=no
15687             else
15688               # We're done! :-)
15689               BOOT_JDK_FOUND=yes
15690 
15691   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15692 
15693   # Input might be given as Windows format, start by converting to
15694   # unix format.
15695   path="$BOOT_JDK"
15696   new_path=`$CYGPATH -u "$path"`
15697 
15698   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15699   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15700   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15701   # "foo.exe" is OK but "foo" is an error.
15702   #
15703   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15704   # It is also a way to make sure we got the proper file name for the real test later on.
15705   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

3848 
3849 # Check if the VS env variables were setup prior to running configure.
3850 # If not, then find vcvarsall.bat and run it automatically, and integrate
3851 # the set env variables into the spec file.
3852 
3853 
3854 
3855 
3856 
3857 
3858 
3859 
3860 
3861 
3862 # This line needs to be here, verbatim, after all includes and the dummy hook
3863 # definitions. It is replaced with custom functionality when building
3864 # custom sources.
3865 #CUSTOM_AUTOCONF_INCLUDE
3866 
3867 # Do not change or remove the following line, it is needed for consistency checks:
3868 DATE_WHEN_GENERATED=1387458146
3869 
3870 ###############################################################################
3871 #
3872 # Initialization / Boot-strapping
3873 #
3874 # The bootstrapping process needs to solve the "chicken or the egg" problem,
3875 # thus it jumps back and forth, each time gaining something needed later on.
3876 #
3877 ###############################################################################
3878 
3879 # Basic initialization that must happen first of all
3880 
3881   # Save the original command line. This is passed to us by the wrapper configure script.
3882 
3883   DATE_WHEN_CONFIGURED=`LANG=C date`
3884 
3885   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
3886 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
3887   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
3888 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}

11264         BOOT_JDK_FOUND=no
11265       else
11266         # Do we have a bin/javac?
11267         if test ! -x "$BOOT_JDK/bin/javac"; then
11268           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
11269 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
11270           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
11271 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
11272           BOOT_JDK_FOUND=no
11273         else
11274           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
11275           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
11276             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
11277 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
11278             BOOT_JDK_FOUND=no
11279           else
11280             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
11281             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
11282 
11283             # Extra M4 quote needed to protect [] in grep expression.
11284             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
11285             if test "x$FOUND_VERSION_89" = x; then
11286               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
11287 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
11288               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
11289 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
11290               BOOT_JDK_FOUND=no
11291             else
11292               # We're done! :-)
11293               BOOT_JDK_FOUND=yes
11294 
11295   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
11296 
11297   # Input might be given as Windows format, start by converting to
11298   # unix format.
11299   path="$BOOT_JDK"
11300   new_path=`$CYGPATH -u "$path"`
11301 
11302   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
11303   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
11304   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
11305   # "foo.exe" is OK but "foo" is an error.
11306   #
11307   # This test is therefore slightly more accurate than "test -f" to check for file precense.
11308   # It is also a way to make sure we got the proper file name for the real test later on.
11309   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

11596         BOOT_JDK_FOUND=no
11597       else
11598         # Do we have a bin/javac?
11599         if test ! -x "$BOOT_JDK/bin/javac"; then
11600           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
11601 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
11602           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
11603 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
11604           BOOT_JDK_FOUND=no
11605         else
11606           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
11607           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
11608             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
11609 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
11610             BOOT_JDK_FOUND=no
11611           else
11612             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
11613             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
11614 
11615             # Extra M4 quote needed to protect [] in grep expression.
11616             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
11617             if test "x$FOUND_VERSION_89" = x; then
11618               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
11619 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
11620               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
11621 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
11622               BOOT_JDK_FOUND=no
11623             else
11624               # We're done! :-)
11625               BOOT_JDK_FOUND=yes
11626 
11627   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
11628 
11629   # Input might be given as Windows format, start by converting to
11630   # unix format.
11631   path="$BOOT_JDK"
11632   new_path=`$CYGPATH -u "$path"`
11633 
11634   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
11635   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
11636   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
11637   # "foo.exe" is OK but "foo" is an error.
11638   #
11639   # This test is therefore slightly more accurate than "test -f" to check for file precense.
11640   # It is also a way to make sure we got the proper file name for the real test later on.
11641   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

11914         BOOT_JDK_FOUND=no
11915       else
11916         # Do we have a bin/javac?
11917         if test ! -x "$BOOT_JDK/bin/javac"; then
11918           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
11919 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
11920           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
11921 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
11922           BOOT_JDK_FOUND=no
11923         else
11924           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
11925           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
11926             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
11927 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
11928             BOOT_JDK_FOUND=no
11929           else
11930             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
11931             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
11932 
11933             # Extra M4 quote needed to protect [] in grep expression.
11934             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
11935             if test "x$FOUND_VERSION_89" = x; then
11936               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
11937 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
11938               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
11939 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
11940               BOOT_JDK_FOUND=no
11941             else
11942               # We're done! :-)
11943               BOOT_JDK_FOUND=yes
11944 
11945   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
11946 
11947   # Input might be given as Windows format, start by converting to
11948   # unix format.
11949   path="$BOOT_JDK"
11950   new_path=`$CYGPATH -u "$path"`
11951 
11952   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
11953   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
11954   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
11955   # "foo.exe" is OK but "foo" is an error.
11956   #
11957   # This test is therefore slightly more accurate than "test -f" to check for file precense.
11958   # It is also a way to make sure we got the proper file name for the real test later on.
11959   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12102         BOOT_JDK_FOUND=no
12103       else
12104         # Do we have a bin/javac?
12105         if test ! -x "$BOOT_JDK/bin/javac"; then
12106           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12107 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12108           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12109 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12110           BOOT_JDK_FOUND=no
12111         else
12112           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12113           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12114             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12115 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12116             BOOT_JDK_FOUND=no
12117           else
12118             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12119             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12120 
12121             # Extra M4 quote needed to protect [] in grep expression.
12122             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
12123             if test "x$FOUND_VERSION_89" = x; then
12124               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12125 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12126               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
12127 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
12128               BOOT_JDK_FOUND=no
12129             else
12130               # We're done! :-)
12131               BOOT_JDK_FOUND=yes
12132 
12133   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12134 
12135   # Input might be given as Windows format, start by converting to
12136   # unix format.
12137   path="$BOOT_JDK"
12138   new_path=`$CYGPATH -u "$path"`
12139 
12140   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12141   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12142   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12143   # "foo.exe" is OK but "foo" is an error.
12144   #
12145   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12146   # It is also a way to make sure we got the proper file name for the real test later on.
12147   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12430         BOOT_JDK_FOUND=no
12431       else
12432         # Do we have a bin/javac?
12433         if test ! -x "$BOOT_JDK/bin/javac"; then
12434           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12435 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12436           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12437 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12438           BOOT_JDK_FOUND=no
12439         else
12440           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12441           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12442             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12443 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12444             BOOT_JDK_FOUND=no
12445           else
12446             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12447             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12448 
12449             # Extra M4 quote needed to protect [] in grep expression.
12450             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
12451             if test "x$FOUND_VERSION_89" = x; then
12452               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12453 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12454               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
12455 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
12456               BOOT_JDK_FOUND=no
12457             else
12458               # We're done! :-)
12459               BOOT_JDK_FOUND=yes
12460 
12461   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12462 
12463   # Input might be given as Windows format, start by converting to
12464   # unix format.
12465   path="$BOOT_JDK"
12466   new_path=`$CYGPATH -u "$path"`
12467 
12468   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12469   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12470   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12471   # "foo.exe" is OK but "foo" is an error.
12472   #
12473   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12474   # It is also a way to make sure we got the proper file name for the real test later on.
12475   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12645         BOOT_JDK_FOUND=no
12646       else
12647         # Do we have a bin/javac?
12648         if test ! -x "$BOOT_JDK/bin/javac"; then
12649           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12650 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12651           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12652 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12653           BOOT_JDK_FOUND=no
12654         else
12655           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12656           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12657             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12658 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12659             BOOT_JDK_FOUND=no
12660           else
12661             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12662             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12663 
12664             # Extra M4 quote needed to protect [] in grep expression.
12665             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
12666             if test "x$FOUND_VERSION_89" = x; then
12667               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12668 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12669               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
12670 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
12671               BOOT_JDK_FOUND=no
12672             else
12673               # We're done! :-)
12674               BOOT_JDK_FOUND=yes
12675 
12676   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12677 
12678   # Input might be given as Windows format, start by converting to
12679   # unix format.
12680   path="$BOOT_JDK"
12681   new_path=`$CYGPATH -u "$path"`
12682 
12683   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12684   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12685   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12686   # "foo.exe" is OK but "foo" is an error.
12687   #
12688   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12689   # It is also a way to make sure we got the proper file name for the real test later on.
12690   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

12825         BOOT_JDK_FOUND=no
12826       else
12827         # Do we have a bin/javac?
12828         if test ! -x "$BOOT_JDK/bin/javac"; then
12829           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
12830 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
12831           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
12832 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
12833           BOOT_JDK_FOUND=no
12834         else
12835           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
12836           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
12837             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
12838 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
12839             BOOT_JDK_FOUND=no
12840           else
12841             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
12842             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
12843 
12844             # Extra M4 quote needed to protect [] in grep expression.
12845             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
12846             if test "x$FOUND_VERSION_89" = x; then
12847               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
12848 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
12849               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
12850 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
12851               BOOT_JDK_FOUND=no
12852             else
12853               # We're done! :-)
12854               BOOT_JDK_FOUND=yes
12855 
12856   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
12857 
12858   # Input might be given as Windows format, start by converting to
12859   # unix format.
12860   path="$BOOT_JDK"
12861   new_path=`$CYGPATH -u "$path"`
12862 
12863   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
12864   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
12865   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
12866   # "foo.exe" is OK but "foo" is an error.
12867   #
12868   # This test is therefore slightly more accurate than "test -f" to check for file precense.
12869   # It is also a way to make sure we got the proper file name for the real test later on.
12870   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13033         BOOT_JDK_FOUND=no
13034       else
13035         # Do we have a bin/javac?
13036         if test ! -x "$BOOT_JDK/bin/javac"; then
13037           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13038 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13039           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13040 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13041           BOOT_JDK_FOUND=no
13042         else
13043           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13044           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13045             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13046 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13047             BOOT_JDK_FOUND=no
13048           else
13049             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13050             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13051 
13052             # Extra M4 quote needed to protect [] in grep expression.
13053             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
13054             if test "x$FOUND_VERSION_89" = x; then
13055               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13056 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13057               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
13058 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
13059               BOOT_JDK_FOUND=no
13060             else
13061               # We're done! :-)
13062               BOOT_JDK_FOUND=yes
13063 
13064   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13065 
13066   # Input might be given as Windows format, start by converting to
13067   # unix format.
13068   path="$BOOT_JDK"
13069   new_path=`$CYGPATH -u "$path"`
13070 
13071   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13072   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13073   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13074   # "foo.exe" is OK but "foo" is an error.
13075   #
13076   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13077   # It is also a way to make sure we got the proper file name for the real test later on.
13078   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13213         BOOT_JDK_FOUND=no
13214       else
13215         # Do we have a bin/javac?
13216         if test ! -x "$BOOT_JDK/bin/javac"; then
13217           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13219           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13220 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13221           BOOT_JDK_FOUND=no
13222         else
13223           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13224           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13225             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13226 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13227             BOOT_JDK_FOUND=no
13228           else
13229             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13230             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13231 
13232             # Extra M4 quote needed to protect [] in grep expression.
13233             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
13234             if test "x$FOUND_VERSION_89" = x; then
13235               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13236 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13237               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
13238 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
13239               BOOT_JDK_FOUND=no
13240             else
13241               # We're done! :-)
13242               BOOT_JDK_FOUND=yes
13243 
13244   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13245 
13246   # Input might be given as Windows format, start by converting to
13247   # unix format.
13248   path="$BOOT_JDK"
13249   new_path=`$CYGPATH -u "$path"`
13250 
13251   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13252   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13253   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13254   # "foo.exe" is OK but "foo" is an error.
13255   #
13256   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13257   # It is also a way to make sure we got the proper file name for the real test later on.
13258   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13421         BOOT_JDK_FOUND=no
13422       else
13423         # Do we have a bin/javac?
13424         if test ! -x "$BOOT_JDK/bin/javac"; then
13425           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13426 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13427           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13428 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13429           BOOT_JDK_FOUND=no
13430         else
13431           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13432           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13433             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13434 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13435             BOOT_JDK_FOUND=no
13436           else
13437             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13438             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13439 
13440             # Extra M4 quote needed to protect [] in grep expression.
13441             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
13442             if test "x$FOUND_VERSION_89" = x; then
13443               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13444 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13445               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
13446 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
13447               BOOT_JDK_FOUND=no
13448             else
13449               # We're done! :-)
13450               BOOT_JDK_FOUND=yes
13451 
13452   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13453 
13454   # Input might be given as Windows format, start by converting to
13455   # unix format.
13456   path="$BOOT_JDK"
13457   new_path=`$CYGPATH -u "$path"`
13458 
13459   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13460   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13461   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13462   # "foo.exe" is OK but "foo" is an error.
13463   #
13464   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13465   # It is also a way to make sure we got the proper file name for the real test later on.
13466   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13601         BOOT_JDK_FOUND=no
13602       else
13603         # Do we have a bin/javac?
13604         if test ! -x "$BOOT_JDK/bin/javac"; then
13605           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13606 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13607           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13608 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13609           BOOT_JDK_FOUND=no
13610         else
13611           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13612           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13613             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13614 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13615             BOOT_JDK_FOUND=no
13616           else
13617             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13618             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13619 
13620             # Extra M4 quote needed to protect [] in grep expression.
13621             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
13622             if test "x$FOUND_VERSION_89" = x; then
13623               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13624 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13625               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
13626 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
13627               BOOT_JDK_FOUND=no
13628             else
13629               # We're done! :-)
13630               BOOT_JDK_FOUND=yes
13631 
13632   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13633 
13634   # Input might be given as Windows format, start by converting to
13635   # unix format.
13636   path="$BOOT_JDK"
13637   new_path=`$CYGPATH -u "$path"`
13638 
13639   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13640   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13641   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13642   # "foo.exe" is OK but "foo" is an error.
13643   #
13644   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13645   # It is also a way to make sure we got the proper file name for the real test later on.
13646   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13809         BOOT_JDK_FOUND=no
13810       else
13811         # Do we have a bin/javac?
13812         if test ! -x "$BOOT_JDK/bin/javac"; then
13813           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13814 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13815           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13816 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13817           BOOT_JDK_FOUND=no
13818         else
13819           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
13820           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
13821             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
13822 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
13823             BOOT_JDK_FOUND=no
13824           else
13825             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
13826             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
13827 
13828             # Extra M4 quote needed to protect [] in grep expression.
13829             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
13830             if test "x$FOUND_VERSION_89" = x; then
13831               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
13832 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
13833               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
13834 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
13835               BOOT_JDK_FOUND=no
13836             else
13837               # We're done! :-)
13838               BOOT_JDK_FOUND=yes
13839 
13840   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13841 
13842   # Input might be given as Windows format, start by converting to
13843   # unix format.
13844   path="$BOOT_JDK"
13845   new_path=`$CYGPATH -u "$path"`
13846 
13847   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13848   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13849   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13850   # "foo.exe" is OK but "foo" is an error.
13851   #
13852   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13853   # It is also a way to make sure we got the proper file name for the real test later on.
13854   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

13989         BOOT_JDK_FOUND=no
13990       else
13991         # Do we have a bin/javac?
13992         if test ! -x "$BOOT_JDK/bin/javac"; then
13993           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
13994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
13995           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
13996 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
13997           BOOT_JDK_FOUND=no
13998         else
13999           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14000           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14001             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14002 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14003             BOOT_JDK_FOUND=no
14004           else
14005             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14006             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14007 
14008             # Extra M4 quote needed to protect [] in grep expression.
14009             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
14010             if test "x$FOUND_VERSION_89" = x; then
14011               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14012 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14013               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
14014 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
14015               BOOT_JDK_FOUND=no
14016             else
14017               # We're done! :-)
14018               BOOT_JDK_FOUND=yes
14019 
14020   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14021 
14022   # Input might be given as Windows format, start by converting to
14023   # unix format.
14024   path="$BOOT_JDK"
14025   new_path=`$CYGPATH -u "$path"`
14026 
14027   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14028   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14029   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14030   # "foo.exe" is OK but "foo" is an error.
14031   #
14032   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14033   # It is also a way to make sure we got the proper file name for the real test later on.
14034   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14184         BOOT_JDK_FOUND=no
14185       else
14186         # Do we have a bin/javac?
14187         if test ! -x "$BOOT_JDK/bin/javac"; then
14188           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14189 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14190           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14191 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14192           BOOT_JDK_FOUND=no
14193         else
14194           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14195           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14196             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14197 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14198             BOOT_JDK_FOUND=no
14199           else
14200             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14201             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14202 
14203             # Extra M4 quote needed to protect [] in grep expression.
14204             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
14205             if test "x$FOUND_VERSION_89" = x; then
14206               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14207 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14208               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
14209 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
14210               BOOT_JDK_FOUND=no
14211             else
14212               # We're done! :-)
14213               BOOT_JDK_FOUND=yes
14214 
14215   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14216 
14217   # Input might be given as Windows format, start by converting to
14218   # unix format.
14219   path="$BOOT_JDK"
14220   new_path=`$CYGPATH -u "$path"`
14221 
14222   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14223   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14224   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14225   # "foo.exe" is OK but "foo" is an error.
14226   #
14227   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14228   # It is also a way to make sure we got the proper file name for the real test later on.
14229   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14362         BOOT_JDK_FOUND=no
14363       else
14364         # Do we have a bin/javac?
14365         if test ! -x "$BOOT_JDK/bin/javac"; then
14366           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14367 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14368           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14369 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14370           BOOT_JDK_FOUND=no
14371         else
14372           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14373           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14374             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14375 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14376             BOOT_JDK_FOUND=no
14377           else
14378             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14379             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14380 
14381             # Extra M4 quote needed to protect [] in grep expression.
14382             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
14383             if test "x$FOUND_VERSION_89" = x; then
14384               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14385 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14386               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
14387 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
14388               BOOT_JDK_FOUND=no
14389             else
14390               # We're done! :-)
14391               BOOT_JDK_FOUND=yes
14392 
14393   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14394 
14395   # Input might be given as Windows format, start by converting to
14396   # unix format.
14397   path="$BOOT_JDK"
14398   new_path=`$CYGPATH -u "$path"`
14399 
14400   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14401   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14402   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14403   # "foo.exe" is OK but "foo" is an error.
14404   #
14405   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14406   # It is also a way to make sure we got the proper file name for the real test later on.
14407   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14558         BOOT_JDK_FOUND=no
14559       else
14560         # Do we have a bin/javac?
14561         if test ! -x "$BOOT_JDK/bin/javac"; then
14562           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14563 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14564           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14565 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14566           BOOT_JDK_FOUND=no
14567         else
14568           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14569           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14570             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14571 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14572             BOOT_JDK_FOUND=no
14573           else
14574             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14575             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14576 
14577             # Extra M4 quote needed to protect [] in grep expression.
14578             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
14579             if test "x$FOUND_VERSION_89" = x; then
14580               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14581 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14582               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
14583 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
14584               BOOT_JDK_FOUND=no
14585             else
14586               # We're done! :-)
14587               BOOT_JDK_FOUND=yes
14588 
14589   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14590 
14591   # Input might be given as Windows format, start by converting to
14592   # unix format.
14593   path="$BOOT_JDK"
14594   new_path=`$CYGPATH -u "$path"`
14595 
14596   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14597   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14598   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14599   # "foo.exe" is OK but "foo" is an error.
14600   #
14601   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14602   # It is also a way to make sure we got the proper file name for the real test later on.
14603   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14736         BOOT_JDK_FOUND=no
14737       else
14738         # Do we have a bin/javac?
14739         if test ! -x "$BOOT_JDK/bin/javac"; then
14740           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14741 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14742           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14743 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14744           BOOT_JDK_FOUND=no
14745         else
14746           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14747           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14748             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14749 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14750             BOOT_JDK_FOUND=no
14751           else
14752             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14753             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14754 
14755             # Extra M4 quote needed to protect [] in grep expression.
14756             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
14757             if test "x$FOUND_VERSION_89" = x; then
14758               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14759 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14760               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
14761 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
14762               BOOT_JDK_FOUND=no
14763             else
14764               # We're done! :-)
14765               BOOT_JDK_FOUND=yes
14766 
14767   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14768 
14769   # Input might be given as Windows format, start by converting to
14770   # unix format.
14771   path="$BOOT_JDK"
14772   new_path=`$CYGPATH -u "$path"`
14773 
14774   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14775   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14776   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14777   # "foo.exe" is OK but "foo" is an error.
14778   #
14779   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14780   # It is also a way to make sure we got the proper file name for the real test later on.
14781   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

14931         BOOT_JDK_FOUND=no
14932       else
14933         # Do we have a bin/javac?
14934         if test ! -x "$BOOT_JDK/bin/javac"; then
14935           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
14936 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
14937           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
14938 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
14939           BOOT_JDK_FOUND=no
14940         else
14941           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
14942           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
14943             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
14944 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
14945             BOOT_JDK_FOUND=no
14946           else
14947             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
14948             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
14949 
14950             # Extra M4 quote needed to protect [] in grep expression.
14951             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
14952             if test "x$FOUND_VERSION_89" = x; then
14953               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
14954 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
14955               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
14956 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
14957               BOOT_JDK_FOUND=no
14958             else
14959               # We're done! :-)
14960               BOOT_JDK_FOUND=yes
14961 
14962   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14963 
14964   # Input might be given as Windows format, start by converting to
14965   # unix format.
14966   path="$BOOT_JDK"
14967   new_path=`$CYGPATH -u "$path"`
14968 
14969   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14970   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14971   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14972   # "foo.exe" is OK but "foo" is an error.
14973   #
14974   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14975   # It is also a way to make sure we got the proper file name for the real test later on.
14976   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15109         BOOT_JDK_FOUND=no
15110       else
15111         # Do we have a bin/javac?
15112         if test ! -x "$BOOT_JDK/bin/javac"; then
15113           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15114 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15115           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15116 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15117           BOOT_JDK_FOUND=no
15118         else
15119           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15120           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15121             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15122 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15123             BOOT_JDK_FOUND=no
15124           else
15125             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15126             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15127 
15128             # Extra M4 quote needed to protect [] in grep expression.
15129             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
15130             if test "x$FOUND_VERSION_89" = x; then
15131               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15132 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15133               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
15134 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
15135               BOOT_JDK_FOUND=no
15136             else
15137               # We're done! :-)
15138               BOOT_JDK_FOUND=yes
15139 
15140   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15141 
15142   # Input might be given as Windows format, start by converting to
15143   # unix format.
15144   path="$BOOT_JDK"
15145   new_path=`$CYGPATH -u "$path"`
15146 
15147   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15148   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15149   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15150   # "foo.exe" is OK but "foo" is an error.
15151   #
15152   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15153   # It is also a way to make sure we got the proper file name for the real test later on.
15154   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15305         BOOT_JDK_FOUND=no
15306       else
15307         # Do we have a bin/javac?
15308         if test ! -x "$BOOT_JDK/bin/javac"; then
15309           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15310 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15311           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15312 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15313           BOOT_JDK_FOUND=no
15314         else
15315           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15316           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15317             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15318 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15319             BOOT_JDK_FOUND=no
15320           else
15321             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15322             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15323 
15324             # Extra M4 quote needed to protect [] in grep expression.
15325             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
15326             if test "x$FOUND_VERSION_89" = x; then
15327               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15328 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15329               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
15330 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
15331               BOOT_JDK_FOUND=no
15332             else
15333               # We're done! :-)
15334               BOOT_JDK_FOUND=yes
15335 
15336   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15337 
15338   # Input might be given as Windows format, start by converting to
15339   # unix format.
15340   path="$BOOT_JDK"
15341   new_path=`$CYGPATH -u "$path"`
15342 
15343   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15344   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15345   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15346   # "foo.exe" is OK but "foo" is an error.
15347   #
15348   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15349   # It is also a way to make sure we got the proper file name for the real test later on.
15350   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15483         BOOT_JDK_FOUND=no
15484       else
15485         # Do we have a bin/javac?
15486         if test ! -x "$BOOT_JDK/bin/javac"; then
15487           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15488 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15489           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15490 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15491           BOOT_JDK_FOUND=no
15492         else
15493           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15494           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15495             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15496 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15497             BOOT_JDK_FOUND=no
15498           else
15499             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15500             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15501 
15502             # Extra M4 quote needed to protect [] in grep expression.
15503             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
15504             if test "x$FOUND_VERSION_89" = x; then
15505               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15506 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15507               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
15508 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
15509               BOOT_JDK_FOUND=no
15510             else
15511               # We're done! :-)
15512               BOOT_JDK_FOUND=yes
15513 
15514   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15515 
15516   # Input might be given as Windows format, start by converting to
15517   # unix format.
15518   path="$BOOT_JDK"
15519   new_path=`$CYGPATH -u "$path"`
15520 
15521   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15522   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15523   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15524   # "foo.exe" is OK but "foo" is an error.
15525   #
15526   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15527   # It is also a way to make sure we got the proper file name for the real test later on.
15528   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`

15660         BOOT_JDK_FOUND=no
15661       else
15662         # Do we have a bin/javac?
15663         if test ! -x "$BOOT_JDK/bin/javac"; then
15664           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
15665 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
15666           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
15667 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
15668           BOOT_JDK_FOUND=no
15669         else
15670           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
15671           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
15672             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
15673 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
15674             BOOT_JDK_FOUND=no
15675           else
15676             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
15677             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
15678 
15679             # Extra M4 quote needed to protect [] in grep expression.
15680             FOUND_VERSION_89=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
15681             if test "x$FOUND_VERSION_89" = x; then
15682               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
15683 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
15684               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
15685 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
15686               BOOT_JDK_FOUND=no
15687             else
15688               # We're done! :-)
15689               BOOT_JDK_FOUND=yes
15690 
15691   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15692 
15693   # Input might be given as Windows format, start by converting to
15694   # unix format.
15695   path="$BOOT_JDK"
15696   new_path=`$CYGPATH -u "$path"`
15697 
15698   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15699   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15700   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15701   # "foo.exe" is OK but "foo" is an error.
15702   #
15703   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15704   # It is also a way to make sure we got the proper file name for the real test later on.
15705   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`